ILog.cs

using System;
using System.Diagnostics;

namespace WPFMediaKit
{
    /// <summary>
    /// A logger.
    /// </summary>
    public interface ILog
    {
        /// <summary>
        /// If the info level is enabled.
        /// </summary>
        bool IsInfoEnabled { get; }

        /// <summary>
        /// If the debug level is enabled.
        /// </summary>
        bool IsDebugEnabled { get; }

        /// <summary>
        /// Logs the error message with a possible exception.
        /// </summary>
        /// <param name="exception">The exception. May be null.</param>
        /// <param name="message">A (formatted) message.</param>
        /// <param name="args">Arguments to the formatted message. May be missing.
        void Error(Exception exception, string message, params object[] args);

        /// <summary>
        /// Logs the warning message.
        /// </summary>
        /// <param name="message">A (formatted) message.</param>
        /// <param name="args">Arguments to the formatted message. May be missing.
        void Warn(string message, params object[] args);

        /// <summary>
        /// Logs the info message.
        /// </summary>
        /// <param name="message">A (formatted) message.</param>
        /// <param name="args">Arguments to the formatted message. May be missing.
        void Info(string message, params object[] args);

        /// <summary>
        /// Logs the debug message.
        /// </summary>
        /// <param name="message">A (formatted) message.</param>
        /// <param name="args">Arguments to the formatted message. May be missing.
        void Debug(string message, params object[] args);
    }

    public static class ILogExtensions
    {
        /// <summary>
        /// Log the error without an exception.
        /// </summary>
        public static void Error(this ILog thiz, string message, params object[] args)
            => thiz.Error(null, message, args);
    }

    /// <summary>
    /// Logging to <see cref="System.Diagnostics.Trace"/>.
    /// </summary>
    public class DebugTraceLog : ILog
    {
        private string _name;

        public DebugTraceLog(string name)
        {
            _name = name;
        }

        public virtual bool IsInfoEnabled => true;

        public virtual bool IsDebugEnabled => true;

        public virtual void Error(Exception exception, string message, params object[] args)
        {
            Trace.TraceError(AddName(message), args);
            if (exception != null)
                Trace.TraceError(exception.ToString());
        }

        public virtual void Warn(string message, params object[] args)
        {
            Trace.TraceWarning(AddName(message), args);
        }

        public virtual void Info(string message, params object[] args)
        {
            if (!IsInfoEnabled)
                return;
            Trace.TraceInformation(AddName(message), args);
        }

        public virtual void Debug(string message, params object[] args)
        {
            if (!IsDebugEnabled)
                return;
            Trace.WriteLine(string.Format(AddName(message), args));
        }

        protected virtual string AddName(string message)
        {
            if (string.IsNullOrEmpty(_name))
                return message;
            return _name + " - " + message;
        }
    }

    /// <summary>
    /// No-op implementation of ILog.
    /// </summary>
    public class NullLog : ILog
    {
        private static NullLog _instance;

        public static NullLog Instance
            => _instance != null ? _instance : (_instance = new NullLog());

        public bool IsInfoEnabled => false;

        public virtual bool IsDebugEnabled => false;

        public void Error(Exception exception, string message, params object[] args)
        { }

        public void Info(string message, params object[] args)
        { }

        public void Debug(string message, params object[] args)
        { }

        public void Warn(string message, params object[] args)
        { }
    }
}