Skip to content

@ferventcoder /0HowAwesomeIsThis.cs
Created

Embed URL

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
this.Log()
public class SomeClass {
public void SomeMethod() {
this.Log().Info(() => "Here is a log message with params which can be in Razor Views as well: '{0}'".FormatWith(typeof(SomeClass).Name));
}
}
Log.InitializeWith<Log4NetLog>();
/// <summary>
/// Extensions to help make logging awesome
/// </summary>
public static class LogExtensions
{
/// <summary>
/// Concurrent dictionary that ensures only one instance of a logger for a type.
/// </summary>
private static readonly Lazy<ConcurrentDictionary<string,ILog>> _dictionary = new Lazy<ConcurrentDictionary<string, ILog>>(()=>new ConcurrentDictionary<string, ILog>());
/// <summary>
/// Gets the logger for <see cref="T"/>.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="type">The type to get the logger for.</param>
/// <returns>Instance of a logger for the object.</returns>
public static ILog Log<T>(this T type)
{
string objectName = typeof(T).FullName;
return Log(objectName);
}
/// <summary>
/// Gets the logger for the specified object name.
/// </summary>
/// <param name="objectName">Either use the fully qualified object name or the short. If used with Log&lt;T&gt;() you must use the fully qualified object name"/></param>
/// <returns>Instance of a logger for the object.</returns>
public static ILog Log(this string objectName)
{
return _dictionary.Value.GetOrAdd(objectName, Infrastructure.Logging.Log.GetLoggerFor);
}
}
/// <summary>
/// Logger type initialization
/// </summary>
public static class Log
{
private static Type _logType = typeof(NullLog);
private static ILog _logger;
/// <summary>
/// Sets up logging to be with a certain type
/// </summary>
/// <typeparam name="T">The type of ILog for the application to use</typeparam>
public static void InitializeWith<T>() where T : ILog, new()
{
_logType = typeof(T);
}
/// <summary>
/// Sets up logging to be with a certain instance. The other method is preferred.
/// </summary>
/// <param name="loggerType">Type of the logger.</param>
/// <remarks>This is mostly geared towards testing</remarks>
public static void InitializeWith(ILog loggerType)
{
_logType = loggerType.GetType();
_logger = loggerType;
}
/// <summary>
/// Initializes a new instance of a logger for an object.
/// This should be done only once per object name.
/// </summary>
/// <param name="objectName">Name of the object.</param>
/// <returns>ILog instance for an object if log type has been intialized; otherwise null</returns>
public static ILog GetLoggerFor(string objectName)
{
var logger = _logger;
if (_logger == null)
{
logger = Activator.CreateInstance(_logType) as ILog;
if (logger != null)
{
logger.InitializeFor(objectName);
}
}
return logger;
}
}
/// <summary>
/// Custom interface for logging messages
/// </summary>
public interface ILog
{
/// <summary>
/// Initializes the instance for the logger name
/// </summary>
/// <param name="loggerName">Name of the logger</param>
void InitializeFor(string loggerName);
/// <summary>
/// Debug level of the specified message. The other method is preferred since the execution is deferred.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="formatting">The formatting.</param>
void Debug(string message, params object[] formatting);
/// <summary>
/// Debug level of the specified message.
/// </summary>
/// <param name="message">The message.</param>
void Debug(Func<string> message);
/// <summary>
/// Info level of the specified message. The other method is preferred since the execution is deferred.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="formatting">The formatting.</param>
void Info(string message, params object[] formatting);
/// <summary>
/// Info level of the specified message.
/// </summary>
/// <param name="message">The message.</param>
void Info(Func<string> message);
/// <summary>
/// Warn level of the specified message. The other method is preferred since the execution is deferred.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="formatting">The formatting.</param>
void Warn(string message, params object[] formatting);
/// <summary>
/// Warn level of the specified message.
/// </summary>
/// <param name="message">The message.</param>
void Warn(Func<string> message);
/// <summary>
/// Error level of the specified message. The other method is preferred since the execution is deferred.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="formatting">The formatting.</param>
void Error(string message, params object[] formatting);
/// <summary>
/// Error level of the specified message.
/// </summary>
/// <param name="message">The message.</param>
void Error(Func<string> message);
/// <summary>
/// Fatal level of the specified message. The other method is preferred since the execution is deferred.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="formatting">The formatting.</param>
void Fatal(string message, params object[] formatting);
/// <summary>
/// Fatal level of the specified message.
/// </summary>
/// <param name="message">The message.</param>
void Fatal(Func<string> message);
}
/// <summary>
/// Ensures a default constructor for the logger type
/// </summary>
/// <typeparam name="T"></typeparam>
public interface ILog<T> where T : new()
{
}
}
/// <summary>
/// The default logger until one is set.
/// </summary>
public class NullLog : ILog, ILog<NullLog>
{
public void InitializeFor(string loggerName)
{
}
public void Debug(string message, params object[] formatting)
{
}
public void Debug(Func<string> message)
{
}
public void Info(string message, params object[] formatting)
{
}
public void Info(Func<string> message)
{
}
public void Warn(string message, params object[] formatting)
{
}
public void Warn(Func<string> message)
{
}
public void Error(string message, params object[] formatting)
{
}
public void Error(Func<string> message)
{
}
public void Fatal(string message, params object[] formatting)
{
}
public void Fatal(Func<string> message)
{
}
}
using System;
using log4net;
using log4net.Config;
[assembly: XmlConfigurator(Watch = true)]
namespace Some.Namespace {
/// <summary>
/// Log4net logger implementing special ILog class
/// </summary>
public class Log4NetLog : ILog, ILog<Log4NetLog>
{
private global::log4net.ILog _logger;
public void InitializeFor(string loggerName)
{
_logger = LogManager.GetLogger(loggerName);
}
public void Debug(string message, params object[] formatting)
{
if (_logger.IsDebugEnabled) _logger.DebugFormat(DecorateMessageWithAuditInformation(message), formatting);
}
public void Debug(Func<string> message)
{
if (_logger.IsDebugEnabled) _logger.Debug(DecorateMessageWithAuditInformation(message.Invoke()));
}
public void Info(string message, params object[] formatting)
{
if (_logger.IsInfoEnabled) _logger.InfoFormat(DecorateMessageWithAuditInformation(message), formatting);
}
public void Info(Func<string> message)
{
if (_logger.IsInfoEnabled) _logger.Info(DecorateMessageWithAuditInformation(message.Invoke()));
}
public void Warn(string message, params object[] formatting)
{
if (_logger.IsWarnEnabled) _logger.WarnFormat(DecorateMessageWithAuditInformation(message), formatting);
}
public void Warn(Func<string> message)
{
if (_logger.IsWarnEnabled) _logger.Warn(DecorateMessageWithAuditInformation(message.Invoke()));
}
public void Error(string message, params object[] formatting)
{
// don't need to check for enabled at this level
_logger.ErrorFormat(DecorateMessageWithAuditInformation(message), formatting);
}
public void Error(Func<string> message)
{
// don't need to check for enabled at this level
_logger.Error(DecorateMessageWithAuditInformation(message.Invoke()));
}
public void Fatal(string message, params object[] formatting)
{
// don't need to check for enabled at this level
_logger.FatalFormat(DecorateMessageWithAuditInformation(message), formatting);
}
public void Fatal(Func<string> message)
{
// don't need to check for enabled at this level
_logger.Fatal(DecorateMessageWithAuditInformation(message.Invoke()));
}
public string DecorateMessageWithAuditInformation(string message)
{
string currentUserName = ApplicationParameters.GetCurrentUserName();
if (!string.IsNullOrWhiteSpace(currentUserName))
{
return "{0} - {1}".FormatWith(message, currentUserName);
}
return message;
}
}
}
public static class StringExtensions
{
/// <summary>
/// Formats string with the formatting passed in. This is a shortcut to string.Format().
/// </summary>
/// <param name="input">The input.</param>
/// <param name="formatting">The formatting.</param>
/// <returns>A formatted string.</returns>
public static string FormatWith(this string input, params object[] formatting)
{
return string.Format(input, formatting);
}
}
@chrissie1

Look at the following gits https://gist.github.com/4299744 and tell me what you think.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Something went wrong with that request. Please try again.