FCC/Extension/WayneClassicFdcClient/WayneLogFacade/DotNetLog.cs

using System;

namespace Wayne.Lib.Log
{
    /// <summary>
    /// Internal class that implements a System.Diagnostics.TraceListener and forwards all
    /// write-requests to an embedded DebugLogger.
    /// </summary>
    internal class DotNetLog : System.Diagnostics.TraceListener, IIdentifiableEntity
    {
        #region Fields

        private DebugLogger debugLogger;
        private bool disposed;

        #endregion

        #region Construction

        /// <summary>
        /// Constructor.
        /// </summary>
        internal DotNetLog()
        {
            debugLogger = new DebugLogger(this, true);
        }

        /// <summary>
        /// Destructor.
        /// </summary>
        ~DotNetLog()
        {
            Dispose(false);
        }

        #endregion

        #region IDisposable Members

        /// <summary>
        /// Overrides the System.Diagnostics.TraceListener Dispose()-method.
        /// </summary>
        /// <param name="disposing"></param>
        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);
            if (!disposed)
            {
                Deactivate();

                debugLogger.Dispose();
                debugLogger = null;

                disposed = true;
            }
        }

        #endregion

        #region IIdentifiableEntity Members

        public int Id
        {
            get { return IdentifiableEntity.NoId; }
        }

        public string EntityType
        {
            get { return "DotNetLog"; }
        }

        /// <summary>
        /// This is used by the logger and should never be set by inheriting classes
        /// </summary>
        public string FullEntityName { get; set; }

        public string EntitySubType
        {
            get { return ""; }
        }

        public IIdentifiableEntity ParentEntity
        {
            get { return null; }
        }

        #endregion

        #region Methods: Activate / Deactivate

        /// <summary>
        /// Checks whether the dotnet debug listener should be activated.
        /// </summary>
        internal void CheckActive()
        {
            //if (debugLogger.IsActive())
            //{
            //    // Register myself as a debug listener in the framework.
            //    if (!System.Diagnostics.Debug.Listeners.Contains(this))
            //        System.Diagnostics.Debug.Listeners.Add(this);
            //}
            //else
            //{
            //    // Deregister myself as a debug listener in the framework.
            //    if (System.Diagnostics.Debug.Listeners.Contains(this))
            //        System.Diagnostics.Debug.Listeners.Remove(this);
            //}
        }

        /// <summary>
        /// Deactivates the dotnet debug listener.
        /// </summary>
        internal void Deactivate()
        {
            // Deregister myself as a debug listener in the framework.
            //if (System.Diagnostics.Debug.Listeners.Contains(this))
            //    System.Diagnostics.Debug.Listeners.Remove(this);
        }

        #endregion

        #region Methods: Overrides of the System.Diagnostics.TraceListener

        public override void Write(string message)
        {
            WriteLine(message);
        }

        public override void WriteLine(string message)
        {
            try
            {
                if (!disposed && debugLogger.IsActive())
                    debugLogger.Add(message);
            }
            catch (ObjectDisposedException) { }
        }

        public override void Write(string message, string category)
        {
            WriteLine(message, category);
        }

        public override void WriteLine(string message, string category)
        {
            try
            {
                if (!disposed && debugLogger.IsActive(category))
                    debugLogger.Add(message, category);
            }
            catch (ObjectDisposedException) { }
        }

        #endregion
    }
}