Modified: logging/log4net/trunk/src/Util/ILogExtensions.cs
URL: 
http://svn.apache.org/viewvc/logging/log4net/trunk/src/Util/ILogExtensions.cs?rev=1764545&r1=1764544&r2=1764545&view=diff
==============================================================================
--- logging/log4net/trunk/src/Util/ILogExtensions.cs (original)
+++ logging/log4net/trunk/src/Util/ILogExtensions.cs Wed Oct 12 20:38:35 2016
@@ -1,1741 +1,1741 @@
-#region Apache License
-//
-// Licensed to the Apache Software Foundation (ASF) under one or more 
-// contributor license agreements. See the NOTICE file distributed with
-// this work for additional information regarding copyright ownership. 
-// The ASF licenses this file to you under the Apache License, Version 2.0
-// (the "License"); you may not use this file except in compliance with 
-// the License. You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-#endregion
-
-#if NET_3_5 || NET_4_0 || MONO_3_5 || MONO_4_0 || NETSTANDARD1_3
-
-using System;
-
-using log4net.Core;
-
-namespace log4net.Util
-{
-       /// <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>
-       public static class ILogExtensions
-       {
-               #region Private Static Fields
-
-               /// <summary>
-               /// The fully qualified type of the Logger class.
-               /// </summary>
-               private readonly static Type declaringType = 
typeof(ILogExtensions);
-
-               #endregion //Private Static Fields
-
-               #region debug extensions
-
-               #region debug extensions that uses log message lambda expression
-
-               /// <summary>
-               /// Log a message object with the <see cref="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="ILog.IsDebugEnabled"/> property.
-               /// This check happens always and does not depend on the 
<seealso cref="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="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="Exception"/> 
-               /// to this method will print the name of the <see 
cref="Exception"/> 
-               /// but no stack trace. To print a stack trace use the 
-               /// <see cref="DebugExt(ILog,Func{object},Exception)"/> form 
instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Debug(object)"/>
-               /// <seealso cref="ILog.IsDebugEnabled"/>
-               public static void DebugExt(this ILog logger, Func<object> 
callback)
-               {
-                       try
-                       {
-                               if (!logger.IsDebugEnabled)
-                                       return;
-
-                               logger.Debug(callback());
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Log a message object with the <see cref="Level.Debug"/> 
level including
-               /// the stack trace of the <see cref="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="DebugExt(ILog, object)"/> form for more 
detailed information.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Debug(object)"/>
-               /// <seealso cref="ILog.IsDebugEnabled"/>
-               public static void DebugExt(this ILog logger, Func<object> 
callback, Exception exception)
-               {
-                       try
-                       {
-                               if (!logger.IsDebugEnabled)
-                                       return;
-
-                               logger.Debug(callback(), exception);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               #endregion
-
-               #region debug extension that use the formatter
-
-               /// <overloads>Log a message object with the <see 
cref="Level.Debug"/> level.</overloads> //TODO
-               /// <summary>
-               /// Log a message object with the <see cref="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="ILog.IsDebugEnabled"/> property.
-               /// This check happens always and does not depend on the 
<seealso cref="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="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="Exception"/> 
-               /// to this method will print the name of the <see 
cref="Exception"/> 
-               /// but no stack trace. To print a stack trace use the 
-               /// <see cref="DebugExt(ILog,object,Exception)"/> form instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Debug(object)"/>
-               /// <seealso cref="ILog.IsDebugEnabled"/>
-               public static void DebugExt(this ILog logger, object message)
-               {
-                       try
-                       {
-                               if (!logger.IsDebugEnabled)
-                                       return;
-
-                               logger.Debug(message);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Log a message object with the <see cref="Level.Debug"/> 
level including
-               /// the stack trace of the <see cref="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="DebugExt(ILog, object)"/> form for more 
detailed information.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Debug(object)"/>
-               /// <seealso cref="ILog.IsDebugEnabled"/>
-               public static void DebugExt(this ILog logger, object message, 
Exception exception)
-               {
-                       try
-                       {
-                               if (!logger.IsDebugEnabled)
-                                       return;
-
-                               logger.Debug(message, exception);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               #endregion
-
-               #region debug extension that use string format
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="DebugExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Debug(object)"/>
-               /// <seealso cref="ILog.IsDebugEnabled"/>
-               public static void DebugFormatExt(this ILog logger, string 
format, object arg0)
-               {
-                       try
-                       {
-                               if (!logger.IsDebugEnabled)
-                                       return;
-
-                               logger.DebugFormat(format, arg0);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="DebugExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Debug(object)"/>
-               /// <seealso cref="ILog.IsDebugEnabled"/>
-               public static void DebugFormatExt(this ILog logger, string 
format, params object[] args)
-               {
-                       try
-                       {
-                               if (!logger.IsDebugEnabled)
-                                       return;
-
-                               logger.DebugFormat(format, args);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="Level.Debug"/> level.
-               /// </summary>
-               /// <param name="provider">An <see cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="DebugExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Debug(object)"/>
-               /// <seealso cref="ILog.IsDebugEnabled"/>
-               public static void DebugFormatExt(this ILog logger, 
IFormatProvider provider, string format, params object[] args)
-               {
-                       try
-                       {
-                               if (!logger.IsDebugEnabled)
-                                       return;
-
-                               logger.DebugFormat(provider, format, args);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="DebugExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Debug(object)"/>
-               /// <seealso cref="ILog.IsDebugEnabled"/>
-               public static void DebugFormatExt(this ILog logger, string 
format, object arg0, object arg1)
-               {
-                       try
-                       {
-                               if (!logger.IsDebugEnabled)
-                                       return;
-
-                               logger.DebugFormat(format, arg0, arg1);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="DebugExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Debug(object)"/>
-               /// <seealso cref="ILog.IsDebugEnabled"/>
-               public static void DebugFormatExt(this ILog logger, string 
format, object arg0, object arg1, object arg2)
-               {
-                       try
-                       {
-                               if (!logger.IsDebugEnabled)
-                                       return;
-
-                               logger.DebugFormat(format, arg0, arg1, arg2);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               #endregion
-
-               #endregion
-
-               #region info extensions
-
-               #region info extensions that uses log message lambda expression
-
-               /// <summary>
-               /// Log a message object with the <see cref="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="ILog.IsInfoEnabled"/> property.
-               /// This check happens always and does not depend on the 
<seealso cref="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="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="Exception"/> 
-               /// to this method will print the name of the <see 
cref="Exception"/> 
-               /// but no stack trace. To print a stack trace use the 
-               /// <see cref="InfoExt(ILog,Func{object},Exception)"/> form 
instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Info(object)"/>
-               /// <seealso cref="ILog.IsInfoEnabled"/>
-               public static void InfoExt(this ILog logger, Func<object> 
callback)
-               {
-                       try
-                       {
-                               if (!logger.IsInfoEnabled)
-                                       return;
-
-                               logger.Info(callback());
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Log a message object with the <see cref="Level.Info"/> 
level including
-               /// the stack trace of the <see cref="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="InfoExt(ILog, object)"/> form for more 
detailed information.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Info(object)"/>
-               /// <seealso cref="ILog.IsInfoEnabled"/>
-               public static void InfoExt(this ILog logger, Func<object> 
callback, Exception exception)
-               {
-                       try
-                       {
-                               if (!logger.IsInfoEnabled)
-                                       return;
-
-                               logger.Info(callback(), exception);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               #endregion
-
-               #region info extension that use the formatter
-
-               /// <overloads>Log a message object with the <see 
cref="Level.Info"/> level.</overloads> //TODO
-               /// <summary>
-               /// Log a message object with the <see cref="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="ILog.IsInfoEnabled"/> property.
-               /// This check happens always and does not depend on the 
<seealso cref="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="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="Exception"/> 
-               /// to this method will print the name of the <see 
cref="Exception"/> 
-               /// but no stack trace. To print a stack trace use the 
-               /// <see cref="InfoExt(ILog,object,Exception)"/> form instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Info(object)"/>
-               /// <seealso cref="ILog.IsInfoEnabled"/>
-               public static void InfoExt(this ILog logger, object message)
-               {
-                       try
-                       {
-                               if (!logger.IsInfoEnabled)
-                                       return;
-
-                               logger.Info(message);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Log a message object with the <see cref="Level.Info"/> 
level including
-               /// the stack trace of the <see cref="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="InfoExt(ILog, object)"/> form for more 
detailed information.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Info(object)"/>
-               /// <seealso cref="ILog.IsInfoEnabled"/>
-               public static void InfoExt(this ILog logger, object message, 
Exception exception)
-               {
-                       try
-                       {
-                               if (!logger.IsInfoEnabled)
-                                       return;
-
-                               logger.Info(message, exception);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               #endregion
-
-               #region info extension that use string format
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="InfoExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Info(object)"/>
-               /// <seealso cref="ILog.IsInfoEnabled"/>
-               public static void InfoFormatExt(this ILog logger, string 
format, object arg0)
-               {
-                       try
-                       {
-                               if (!logger.IsInfoEnabled)
-                                       return;
-
-                               logger.InfoFormat(format, arg0);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="InfoExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Info(object)"/>
-               /// <seealso cref="ILog.IsInfoEnabled"/>
-               public static void InfoFormatExt(this ILog logger, string 
format, params object[] args)
-               {
-                       try
-                       {
-                               if (!logger.IsInfoEnabled)
-                                       return;
-
-                               logger.InfoFormat(format, args);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="Level.Info"/> level.
-               /// </summary>
-               /// <param name="provider">An <see cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="InfoExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Info(object)"/>
-               /// <seealso cref="ILog.IsInfoEnabled"/>
-               public static void InfoFormatExt(this ILog logger, 
IFormatProvider provider, string format, params object[] args)
-               {
-                       try
-                       {
-                               if (!logger.IsInfoEnabled)
-                                       return;
-
-                               logger.InfoFormat(provider, format, args);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="InfoExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Info(object)"/>
-               /// <seealso cref="ILog.IsInfoEnabled"/>
-               public static void InfoFormatExt(this ILog logger, string 
format, object arg0, object arg1)
-               {
-                       try
-                       {
-                               if (!logger.IsInfoEnabled)
-                                       return;
-
-                               logger.InfoFormat(format, arg0, arg1);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="InfoExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Info(object)"/>
-               /// <seealso cref="ILog.IsInfoEnabled"/>
-               public static void InfoFormatExt(this ILog logger, string 
format, object arg0, object arg1, object arg2)
-               {
-                       try
-                       {
-                               if (!logger.IsInfoEnabled)
-                                       return;
-
-                               logger.InfoFormat(format, arg0, arg1, arg2);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               #endregion
-
-               #endregion
-
-               #region warn extensions
-
-               #region warn extensions that uses log message lambda expression
-
-               /// <summary>
-               /// Log a message object with the <see cref="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="ILog.IsWarnEnabled"/> property.
-               /// This check happens always and does not depend on the 
<seealso cref="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="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="Exception"/> 
-               /// to this method will print the name of the <see 
cref="Exception"/> 
-               /// but no stack trace. To print a stack trace use the 
-               /// <see cref="WarnExt(ILog,Func{object},Exception)"/> form 
instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Warn(object)"/>
-               /// <seealso cref="ILog.IsWarnEnabled"/>
-               public static void WarnExt(this ILog logger, Func<object> 
callback)
-               {
-                       try
-                       {
-                               if (!logger.IsWarnEnabled)
-                                       return;
-
-                               logger.Warn(callback());
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Log a message object with the <see cref="Level.Warn"/> 
level including
-               /// the stack trace of the <see cref="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="WarnExt(ILog, object)"/> form for more 
detailed information.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Warn(object)"/>
-               /// <seealso cref="ILog.IsWarnEnabled"/>
-               public static void WarnExt(this ILog logger, Func<object> 
callback, Exception exception)
-               {
-                       try
-                       {
-                               if (!logger.IsWarnEnabled)
-                                       return;
-
-                               logger.Warn(callback(), exception);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               #endregion
-
-               #region warn extension that use the formatter
-
-               /// <overloads>Log a message object with the <see 
cref="Level.Warn"/> level.</overloads> //TODO
-               /// <summary>
-               /// Log a message object with the <see cref="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="ILog.IsWarnEnabled"/> property.
-               /// This check happens always and does not depend on the 
<seealso cref="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="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="Exception"/> 
-               /// to this method will print the name of the <see 
cref="Exception"/> 
-               /// but no stack trace. To print a stack trace use the 
-               /// <see cref="WarnExt(ILog,object,Exception)"/> form instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Warn(object)"/>
-               /// <seealso cref="ILog.IsWarnEnabled"/>
-               public static void WarnExt(this ILog logger, object message)
-               {
-                       try
-                       {
-                               if (!logger.IsWarnEnabled)
-                                       return;
-
-                               logger.Warn(message);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Log a message object with the <see cref="Level.Warn"/> 
level including
-               /// the stack trace of the <see cref="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="WarnExt(ILog, object)"/> form for more 
detailed information.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Warn(object)"/>
-               /// <seealso cref="ILog.IsWarnEnabled"/>
-               public static void WarnExt(this ILog logger, object message, 
Exception exception)
-               {
-                       try
-                       {
-                               if (!logger.IsWarnEnabled)
-                                       return;
-
-                               logger.Warn(message, exception);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               #endregion
-
-               #region warn extension that use string format
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="WarnExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Warn(object)"/>
-               /// <seealso cref="ILog.IsWarnEnabled"/>
-               public static void WarnFormatExt(this ILog logger, string 
format, object arg0)
-               {
-                       try
-                       {
-                               if (!logger.IsWarnEnabled)
-                                       return;
-
-                               logger.WarnFormat(format, arg0);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="WarnExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Warn(object)"/>
-               /// <seealso cref="ILog.IsWarnEnabled"/>
-               public static void WarnFormatExt(this ILog logger, string 
format, params object[] args)
-               {
-                       try
-                       {
-                               if (!logger.IsWarnEnabled)
-                                       return;
-
-                               logger.WarnFormat(format, args);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="Level.Warn"/> level.
-               /// </summary>
-               /// <param name="provider">An <see cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="WarnExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Warn(object)"/>
-               /// <seealso cref="ILog.IsWarnEnabled"/>
-               public static void WarnFormatExt(this ILog logger, 
IFormatProvider provider, string format, params object[] args)
-               {
-                       try
-                       {
-                               if (!logger.IsWarnEnabled)
-                                       return;
-
-                               logger.WarnFormat(provider, format, args);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="WarnExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Warn(object)"/>
-               /// <seealso cref="ILog.IsWarnEnabled"/>
-               public static void WarnFormatExt(this ILog logger, string 
format, object arg0, object arg1)
-               {
-                       try
-                       {
-                               if (!logger.IsWarnEnabled)
-                                       return;
-
-                               logger.WarnFormat(format, arg0, arg1);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="WarnExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Warn(object)"/>
-               /// <seealso cref="ILog.IsWarnEnabled"/>
-               public static void WarnFormatExt(this ILog logger, string 
format, object arg0, object arg1, object arg2)
-               {
-                       try
-                       {
-                               if (!logger.IsWarnEnabled)
-                                       return;
-
-                               logger.WarnFormat(format, arg0, arg1, arg2);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               #endregion
-
-               #endregion
-
-               #region error extensions
-
-               #region error extensions that uses log message lambda expression
-
-               /// <summary>
-               /// Log a message object with the <see cref="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="ILog.IsErrorEnabled"/> property.
-               /// This check happens always and does not depend on the 
<seealso cref="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="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="Exception"/> 
-               /// to this method will print the name of the <see 
cref="Exception"/> 
-               /// but no stack trace. To print a stack trace use the 
-               /// <see cref="ErrorExt(ILog,Func{object},Exception)"/> form 
instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Error(object)"/>
-               /// <seealso cref="ILog.IsErrorEnabled"/>
-               public static void ErrorExt(this ILog logger, Func<object> 
callback)
-               {
-                       try
-                       {
-                               if (!logger.IsErrorEnabled)
-                                       return;
-
-                               logger.Error(callback());
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Log a message object with the <see cref="Level.Error"/> 
level including
-               /// the stack trace of the <see cref="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="ErrorExt(ILog, object)"/> form for more 
detailed information.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Error(object)"/>
-               /// <seealso cref="ILog.IsErrorEnabled"/>
-               public static void ErrorExt(this ILog logger, Func<object> 
callback, Exception exception)
-               {
-                       try
-                       {
-                               if (!logger.IsErrorEnabled)
-                                       return;
-
-                               logger.Error(callback(), exception);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               #endregion
-
-               #region error extension that use the formatter
-
-               /// <overloads>Log a message object with the <see 
cref="Level.Error"/> level.</overloads> //TODO
-               /// <summary>
-               /// Log a message object with the <see cref="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="ILog.IsErrorEnabled"/> property.
-               /// This check happens always and does not depend on the 
<seealso cref="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="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="Exception"/> 
-               /// to this method will print the name of the <see 
cref="Exception"/> 
-               /// but no stack trace. To print a stack trace use the 
-               /// <see cref="ErrorExt(ILog,object,Exception)"/> form instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Error(object)"/>
-               /// <seealso cref="ILog.IsErrorEnabled"/>
-               public static void ErrorExt(this ILog logger, object message)
-               {
-                       try
-                       {
-                               if (!logger.IsErrorEnabled)
-                                       return;
-
-                               logger.Error(message);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Log a message object with the <see cref="Level.Error"/> 
level including
-               /// the stack trace of the <see cref="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="ErrorExt(ILog, object)"/> form for more 
detailed information.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Error(object)"/>
-               /// <seealso cref="ILog.IsErrorEnabled"/>
-               public static void ErrorExt(this ILog logger, object message, 
Exception exception)
-               {
-                       try
-                       {
-                               if (!logger.IsErrorEnabled)
-                                       return;
-
-                               logger.Error(message, exception);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               #endregion
-
-               #region error extension that use string format
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="ErrorExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Error(object)"/>
-               /// <seealso cref="ILog.IsErrorEnabled"/>
-               public static void ErrorFormatExt(this ILog logger, string 
format, object arg0)
-               {
-                       try
-                       {
-                               if (!logger.IsErrorEnabled)
-                                       return;
-
-                               logger.ErrorFormat(format, arg0);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="ErrorExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Error(object)"/>
-               /// <seealso cref="ILog.IsErrorEnabled"/>
-               public static void ErrorFormatExt(this ILog logger, string 
format, params object[] args)
-               {
-                       try
-                       {
-                               if (!logger.IsErrorEnabled)
-                                       return;
-
-                               logger.ErrorFormat(format, args);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="Level.Error"/> level.
-               /// </summary>
-               /// <param name="provider">An <see cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="ErrorExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Error(object)"/>
-               /// <seealso cref="ILog.IsErrorEnabled"/>
-               public static void ErrorFormatExt(this ILog logger, 
IFormatProvider provider, string format, params object[] args)
-               {
-                       try
-                       {
-                               if (!logger.IsErrorEnabled)
-                                       return;
-
-                               logger.ErrorFormat(provider, format, args);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="ErrorExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Error(object)"/>
-               /// <seealso cref="ILog.IsErrorEnabled"/>
-               public static void ErrorFormatExt(this ILog logger, string 
format, object arg0, object arg1)
-               {
-                       try
-                       {
-                               if (!logger.IsErrorEnabled)
-                                       return;
-
-                               logger.ErrorFormat(format, arg0, arg1);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="ErrorExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Error(object)"/>
-               /// <seealso cref="ILog.IsErrorEnabled"/>
-               public static void ErrorFormatExt(this ILog logger, string 
format, object arg0, object arg1, object arg2)
-               {
-                       try
-                       {
-                               if (!logger.IsErrorEnabled)
-                                       return;
-
-                               logger.ErrorFormat(format, arg0, arg1, arg2);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               #endregion
-
-               #endregion
-
-               #region fatal extensions
-
-               #region fatal extensions that uses log message lambda expression
-
-               /// <summary>
-               /// Log a message object with the <see cref="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="ILog.IsFatalEnabled"/> property.
-               /// This check happens always and does not depend on the 
<seealso cref="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="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="Exception"/> 
-               /// to this method will print the name of the <see 
cref="Exception"/> 
-               /// but no stack trace. To print a stack trace use the 
-               /// <see cref="FatalExt(ILog,Func{object},Exception)"/> form 
instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Fatal(object)"/>
-               /// <seealso cref="ILog.IsFatalEnabled"/>
-               public static void FatalExt(this ILog logger, Func<object> 
callback)
-               {
-                       try
-                       {
-                               if (!logger.IsFatalEnabled)
-                                       return;
-
-                               logger.Fatal(callback());
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Log a message object with the <see cref="Level.Fatal"/> 
level including
-               /// the stack trace of the <see cref="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="FatalExt(ILog, object)"/> form for more 
detailed information.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Fatal(object)"/>
-               /// <seealso cref="ILog.IsFatalEnabled"/>
-               public static void FatalExt(this ILog logger, Func<object> 
callback, Exception exception)
-               {
-                       try
-                       {
-                               if (!logger.IsFatalEnabled)
-                                       return;
-
-                               logger.Fatal(callback(), exception);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               #endregion
-
-               #region fatal extension that use the formatter
-
-               /// <overloads>Log a message object with the <see 
cref="Level.Fatal"/> level.</overloads> //TODO
-               /// <summary>
-               /// Log a message object with the <see cref="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="ILog.IsFatalEnabled"/> property.
-               /// This check happens always and does not depend on the 
<seealso cref="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="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="Exception"/> 
-               /// to this method will print the name of the <see 
cref="Exception"/> 
-               /// but no stack trace. To print a stack trace use the 
-               /// <see cref="FatalExt(ILog,object,Exception)"/> form instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Fatal(object)"/>
-               /// <seealso cref="ILog.IsFatalEnabled"/>
-               public static void FatalExt(this ILog logger, object message)
-               {
-                       try
-                       {
-                               if (!logger.IsFatalEnabled)
-                                       return;
-
-                               logger.Fatal(message);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Log a message object with the <see cref="Level.Fatal"/> 
level including
-               /// the stack trace of the <see cref="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="FatalExt(ILog, object)"/> form for more 
detailed information.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Fatal(object)"/>
-               /// <seealso cref="ILog.IsFatalEnabled"/>
-               public static void FatalExt(this ILog logger, object message, 
Exception exception)
-               {
-                       try
-                       {
-                               if (!logger.IsFatalEnabled)
-                                       return;
-
-                               logger.Fatal(message, exception);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               #endregion
-
-               #region fatal extension that use string format
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="FatalExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Fatal(object)"/>
-               /// <seealso cref="ILog.IsFatalEnabled"/>
-               public static void FatalFormatExt(this ILog logger, string 
format, object arg0)
-               {
-                       try
-                       {
-                               if (!logger.IsFatalEnabled)
-                                       return;
-
-                               logger.FatalFormat(format, arg0);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="FatalExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Fatal(object)"/>
-               /// <seealso cref="ILog.IsFatalEnabled"/>
-               public static void FatalFormatExt(this ILog logger, string 
format, params object[] args)
-               {
-                       try
-                       {
-                               if (!logger.IsFatalEnabled)
-                                       return;
-
-                               logger.FatalFormat(format, args);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="Level.Fatal"/> level.
-               /// </summary>
-               /// <param name="provider">An <see cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="FatalExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Fatal(object)"/>
-               /// <seealso cref="ILog.IsFatalEnabled"/>
-               public static void FatalFormatExt(this ILog logger, 
IFormatProvider provider, string format, params object[] args)
-               {
-                       try
-                       {
-                               if (!logger.IsFatalEnabled)
-                                       return;
-
-                               logger.FatalFormat(provider, format, args);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="FatalExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Fatal(object)"/>
-               /// <seealso cref="ILog.IsFatalEnabled"/>
-               public static void FatalFormatExt(this ILog logger, string 
format, object arg0, object arg1)
-               {
-                       try
-                       {
-                               if (!logger.IsFatalEnabled)
-                                       return;
-
-                               logger.FatalFormat(format, arg0, arg1);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               /// <summary>
-               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
-               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="FatalExt(ILog,object,Exception)"/>
-               /// methods instead.
-               /// </para>
-               /// </remarks>
-               /// <seealso cref="ILog.Fatal(object)"/>
-               /// <seealso cref="ILog.IsFatalEnabled"/>
-               public static void FatalFormatExt(this ILog logger, string 
format, object arg0, object arg1, object arg2)
-               {
-                       try
-                       {
-                               if (!logger.IsFatalEnabled)
-                                       return;
-
-                               logger.FatalFormat(format, arg0, arg1, arg2);
-                       }
-                       catch (Exception ex)
-                       {
-                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
-                       }
-               }
-
-               #endregion
-
-               #endregion
-       }
-}
-#endif
+#region Apache License
+//
+// Licensed to the Apache Software Foundation (ASF) under one or more 
+// contributor license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership. 
+// The ASF licenses this file to you under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with 
+// the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#endregion
+
+#if NET_3_5 || NET_4_0 || MONO_3_5 || MONO_4_0 || NETSTANDARD1_3
+
+using System;
+
+using log4net.Core;
+
+namespace log4net.Util
+{
+       /// <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>
+       public static class ILogExtensions
+       {
+               #region Private Static Fields
+
+               /// <summary>
+               /// The fully qualified type of the Logger class.
+               /// </summary>
+               private readonly static Type declaringType = 
typeof(ILogExtensions);
+
+               #endregion //Private Static Fields
+
+               #region debug extensions
+
+               #region debug extensions that uses log message lambda expression
+
+               /// <summary>
+               /// Log a message object with the <see cref="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="ILog.IsDebugEnabled"/> property.
+               /// This check happens always and does not depend on the 
<seealso cref="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="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="Exception"/> 
+               /// to this method will print the name of the <see 
cref="Exception"/> 
+               /// but no stack trace. To print a stack trace use the 
+               /// <see cref="DebugExt(ILog,Func{object},Exception)"/> form 
instead.
+               /// </para>
+               /// </remarks>
+               /// <seealso cref="ILog.Debug(object)"/>
+               /// <seealso cref="ILog.IsDebugEnabled"/>
+               public static void DebugExt(this ILog logger, Func<object> 
callback)
+               {
+                       try
+                       {
+                               if (!logger.IsDebugEnabled)
+                                       return;
+
+                               logger.Debug(callback());
+                       }
+                       catch (Exception ex)
+                       {
+                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
+                       }
+               }
+
+               /// <summary>
+               /// Log a message object with the <see cref="Level.Debug"/> 
level including
+               /// the stack trace of the <see cref="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="DebugExt(ILog, object)"/> form for more 
detailed information.
+               /// </para>
+               /// </remarks>
+               /// <seealso cref="ILog.Debug(object)"/>
+               /// <seealso cref="ILog.IsDebugEnabled"/>
+               public static void DebugExt(this ILog logger, Func<object> 
callback, Exception exception)
+               {
+                       try
+                       {
+                               if (!logger.IsDebugEnabled)
+                                       return;
+
+                               logger.Debug(callback(), exception);
+                       }
+                       catch (Exception ex)
+                       {
+                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
+                       }
+               }
+
+               #endregion
+
+               #region debug extension that use the formatter
+
+               /// <overloads>Log a message object with the <see 
cref="Level.Debug"/> level.</overloads> //TODO
+               /// <summary>
+               /// Log a message object with the <see cref="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="ILog.IsDebugEnabled"/> property.
+               /// This check happens always and does not depend on the 
<seealso cref="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="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="Exception"/> 
+               /// to this method will print the name of the <see 
cref="Exception"/> 
+               /// but no stack trace. To print a stack trace use the 
+               /// <see cref="DebugExt(ILog,object,Exception)"/> form instead.
+               /// </para>
+               /// </remarks>
+               /// <seealso cref="ILog.Debug(object)"/>
+               /// <seealso cref="ILog.IsDebugEnabled"/>
+               public static void DebugExt(this ILog logger, object message)
+               {
+                       try
+                       {
+                               if (!logger.IsDebugEnabled)
+                                       return;
+
+                               logger.Debug(message);
+                       }
+                       catch (Exception ex)
+                       {
+                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
+                       }
+               }
+
+               /// <summary>
+               /// Log a message object with the <see cref="Level.Debug"/> 
level including
+               /// the stack trace of the <see cref="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="DebugExt(ILog, object)"/> form for more 
detailed information.
+               /// </para>
+               /// </remarks>
+               /// <seealso cref="ILog.Debug(object)"/>
+               /// <seealso cref="ILog.IsDebugEnabled"/>
+               public static void DebugExt(this ILog logger, object message, 
Exception exception)
+               {
+                       try
+                       {
+                               if (!logger.IsDebugEnabled)
+                                       return;
+
+                               logger.Debug(message, exception);
+                       }
+                       catch (Exception ex)
+                       {
+                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
+                       }
+               }
+
+               #endregion
+
+               #region debug extension that use string format
+
+               /// <summary>
+               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
+               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="DebugExt(ILog,object,Exception)"/>
+               /// methods instead.
+               /// </para>
+               /// </remarks>
+               /// <seealso cref="ILog.Debug(object)"/>
+               /// <seealso cref="ILog.IsDebugEnabled"/>
+               public static void DebugFormatExt(this ILog logger, string 
format, object arg0)
+               {
+                       try
+                       {
+                               if (!logger.IsDebugEnabled)
+                                       return;
+
+                               logger.DebugFormat(format, arg0);
+                       }
+                       catch (Exception ex)
+                       {
+                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
+                       }
+               }
+
+               /// <summary>
+               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
+               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="DebugExt(ILog,object,Exception)"/>
+               /// methods instead.
+               /// </para>
+               /// </remarks>
+               /// <seealso cref="ILog.Debug(object)"/>
+               /// <seealso cref="ILog.IsDebugEnabled"/>
+               public static void DebugFormatExt(this ILog logger, string 
format, params object[] args)
+               {
+                       try
+                       {
+                               if (!logger.IsDebugEnabled)
+                                       return;
+
+                               logger.DebugFormat(format, args);
+                       }
+                       catch (Exception ex)
+                       {
+                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
+                       }
+               }
+
+               /// <summary>
+               /// Logs a formatted message string with the <see 
cref="Level.Debug"/> level.
+               /// </summary>
+               /// <param name="provider">An <see cref="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="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="Exception"/> object 
to include in the
+               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="DebugExt(ILog,object,Exception)"/>
+               /// methods instead.
+               /// </para>
+               /// </remarks>
+               /// <seealso cref="ILog.Debug(object)"/>
+               /// <seealso cref="ILog.IsDebugEnabled"/>
+               public static void DebugFormatExt(this ILog logger, 
IFormatProvider provider, string format, params object[] args)
+               {
+                       try
+                       {
+                               if (!logger.IsDebugEnabled)
+                                       return;
+
+                               logger.DebugFormat(provider, format, args);
+                       }
+                       catch (Exception ex)
+                       {
+                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
+                       }
+               }
+
+               /// <summary>
+               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
+               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="DebugExt(ILog,object,Exception)"/>
+               /// methods instead.
+               /// </para>
+               /// </remarks>
+               /// <seealso cref="ILog.Debug(object)"/>
+               /// <seealso cref="ILog.IsDebugEnabled"/>
+               public static void DebugFormatExt(this ILog logger, string 
format, object arg0, object arg1)
+               {
+                       try
+                       {
+                               if (!logger.IsDebugEnabled)
+                                       return;
+
+                               logger.DebugFormat(format, arg0, arg1);
+                       }
+                       catch (Exception ex)
+                       {
+                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
+                       }
+               }
+
+               /// <summary>
+               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
+               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="DebugExt(ILog,object,Exception)"/>
+               /// methods instead.
+               /// </para>
+               /// </remarks>
+               /// <seealso cref="ILog.Debug(object)"/>
+               /// <seealso cref="ILog.IsDebugEnabled"/>
+               public static void DebugFormatExt(this ILog logger, string 
format, object arg0, object arg1, object arg2)
+               {
+                       try
+                       {
+                               if (!logger.IsDebugEnabled)
+                                       return;
+
+                               logger.DebugFormat(format, arg0, arg1, arg2);
+                       }
+                       catch (Exception ex)
+                       {
+                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
+                       }
+               }
+
+               #endregion
+
+               #endregion
+
+               #region info extensions
+
+               #region info extensions that uses log message lambda expression
+
+               /// <summary>
+               /// Log a message object with the <see cref="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="ILog.IsInfoEnabled"/> property.
+               /// This check happens always and does not depend on the 
<seealso cref="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="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="Exception"/> 
+               /// to this method will print the name of the <see 
cref="Exception"/> 
+               /// but no stack trace. To print a stack trace use the 
+               /// <see cref="InfoExt(ILog,Func{object},Exception)"/> form 
instead.
+               /// </para>
+               /// </remarks>
+               /// <seealso cref="ILog.Info(object)"/>
+               /// <seealso cref="ILog.IsInfoEnabled"/>
+               public static void InfoExt(this ILog logger, Func<object> 
callback)
+               {
+                       try
+                       {
+                               if (!logger.IsInfoEnabled)
+                                       return;
+
+                               logger.Info(callback());
+                       }
+                       catch (Exception ex)
+                       {
+                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
+                       }
+               }
+
+               /// <summary>
+               /// Log a message object with the <see cref="Level.Info"/> 
level including
+               /// the stack trace of the <see cref="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="InfoExt(ILog, object)"/> form for more 
detailed information.
+               /// </para>
+               /// </remarks>
+               /// <seealso cref="ILog.Info(object)"/>
+               /// <seealso cref="ILog.IsInfoEnabled"/>
+               public static void InfoExt(this ILog logger, Func<object> 
callback, Exception exception)
+               {
+                       try
+                       {
+                               if (!logger.IsInfoEnabled)
+                                       return;
+
+                               logger.Info(callback(), exception);
+                       }
+                       catch (Exception ex)
+                       {
+                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
+                       }
+               }
+
+               #endregion
+
+               #region info extension that use the formatter
+
+               /// <overloads>Log a message object with the <see 
cref="Level.Info"/> level.</overloads> //TODO
+               /// <summary>
+               /// Log a message object with the <see cref="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="ILog.IsInfoEnabled"/> property.
+               /// This check happens always and does not depend on the 
<seealso cref="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="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="Exception"/> 
+               /// to this method will print the name of the <see 
cref="Exception"/> 
+               /// but no stack trace. To print a stack trace use the 
+               /// <see cref="InfoExt(ILog,object,Exception)"/> form instead.
+               /// </para>
+               /// </remarks>
+               /// <seealso cref="ILog.Info(object)"/>
+               /// <seealso cref="ILog.IsInfoEnabled"/>
+               public static void InfoExt(this ILog logger, object message)
+               {
+                       try
+                       {
+                               if (!logger.IsInfoEnabled)
+                                       return;
+
+                               logger.Info(message);
+                       }
+                       catch (Exception ex)
+                       {
+                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
+                       }
+               }
+
+               /// <summary>
+               /// Log a message object with the <see cref="Level.Info"/> 
level including
+               /// the stack trace of the <see cref="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="InfoExt(ILog, object)"/> form for more 
detailed information.
+               /// </para>
+               /// </remarks>
+               /// <seealso cref="ILog.Info(object)"/>
+               /// <seealso cref="ILog.IsInfoEnabled"/>
+               public static void InfoExt(this ILog logger, object message, 
Exception exception)
+               {
+                       try
+                       {
+                               if (!logger.IsInfoEnabled)
+                                       return;
+
+                               logger.Info(message, exception);
+                       }
+                       catch (Exception ex)
+                       {
+                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
+                       }
+               }
+
+               #endregion
+
+               #region info extension that use string format
+
+               /// <summary>
+               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
+               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="InfoExt(ILog,object,Exception)"/>
+               /// methods instead.
+               /// </para>
+               /// </remarks>
+               /// <seealso cref="ILog.Info(object)"/>
+               /// <seealso cref="ILog.IsInfoEnabled"/>
+               public static void InfoFormatExt(this ILog logger, string 
format, object arg0)
+               {
+                       try
+                       {
+                               if (!logger.IsInfoEnabled)
+                                       return;
+
+                               logger.InfoFormat(format, arg0);
+                       }
+                       catch (Exception ex)
+                       {
+                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
+                       }
+               }
+
+               /// <summary>
+               /// Logs a formatted message string with the <see 
cref="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="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="Exception"/> object 
to include in the
+               /// log event. To pass an <see cref="Exception"/> use one of 
the <see cref="InfoExt(ILog,object,Exception)"/>
+               /// methods instead.
+               /// </para>
+               /// </remarks>
+               /// <seealso cref="ILog.Info(object)"/>
+               /// <seealso cref="ILog.IsInfoEnabled"/>
+               public static void InfoFormatExt(this ILog logger, string 
format, params object[] args)
+               {
+                       try
+                       {
+                               if (!logger.IsInfoEnabled)
+                                       return;
+
+                               logger.InfoFormat(format, args);
+                       }
+                       catch (Exception ex)
+                       {
+                               log4net.Util.LogLog.Error(declaringType, 
"Exception while logging", ex);
+                       }
+               }
+
+               /// <summary>
+               /// Logs a formatted message string with the <see 
cref="Level.Info"/> level.
+               /// </summary>
+               /// <param name="provider">An <see cref="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="String.Format(string, object[])"/> for details 
of the syntax of the format string and the behavior

[... 1113 lines stripped ...]


Reply via email to