Standardization of Performance Monitoring, Logging, & Exception Handling via a .NET Runtime Wrapper

/*
 * Written by Lee McGraw (in my personal free time), Enterprise Architect/Developer US DoD
 * Feel free to modify this code to suit your own needs.
 * An article accompanies this code, titled "Standardization of Performance Monitoring, Logging, and Exception Handling via a .NET Runtime Wrapper"
 * Google it if you are interested.
 */


using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Runtime.CompilerServices;
using System.Runtime.ExceptionServices;
using System.Runtime.Serialization.Json;
using System.Text;
using static System.Console;
using static System.String;


namespace CoreConsoleAppLee
{
    public class MyReferenceClass
    {
        public string Name { get; set; }
    }
    class Program
    {
        public string InstanceMethod(int num)
        {
            return "Inside of Instance Method. " + num.ToString();
        }
        public static string StaticMethod(int num)
        {
            return "Inside of Static Method. " + num.ToString();
        }


        static void Main(string[] args)
        {
            var myProgram = new Program();
            var uow = new UnitOfWork<int, string>(r =>
            {
                return "Inside of Statement Lambda. " + r.ToString();
            })
            {
                UnitOfWorkName = "Demostration of Unit of Work usage."
            };
            uow.AddFunction(r => "Inside of Expression Lambda." + r.ToString());  
            uow.AddFunction(r => StaticMethod(r));
            uow.AddFunction(r => myProgram.InstanceMethod(r));
            var input = 10;
            uow.Execute(input);


            Console.WriteLine("\nInputs to calls...");
            uow.Inputs.ForEach(r =>
            {
                Console.WriteLine(r.ToString());
            });
            Console.WriteLine("\nOutputs to calls...");
            uow.Outputs.ForEach(r =>
            {
                Console.WriteLine(r.ToString());
            });
            
            var uow2 = new UnitOfWork<MyReferenceClass, MyReferenceClass>(r =>
              {
                  r.Name = r.Name.ToUpper();
                  return r;
              });
            uow2.AddFunction(f =>
            {
                f.Name = f.Name.ToLower();
                return f;
            });
            var res = uow2.Execute(new MyReferenceClass { Name = "Daffy Duck" });


            Console.WriteLine("\nInputs to calls...");
            uow2.Inputs.ForEach(r =>
            {
                Console.WriteLine(r.Name.ToString());
            });
            Console.WriteLine("\nOutputs to calls...");
            uow2.Outputs.ForEach(r =>
            {
                Console.WriteLine(r.Name.ToString());
            });


            var i = 0;
        }
    }


    /// <summary>
    /// This class encapsulates the performance timing, exception handling, and logging of a method and/or a group of methods.  
    /// Do NOT be confused by the name of the class.  It is NOT a database UnitOfWork, although that support could easily be added.  
    /// The purpose of this class is to handle a measurable unit of work, as well as a logical endpoint for exception handling.
    /// </summary>
    /// <typeparam name="IN">Type being passed as input the method; this is not necessarily a single object, because it could be a collection.</typeparam>
    /// <typeparam name="OUT">Type being returned by the method; this is not necessarily a single object, because it could be a collection or a tuple of many types.</typeparam>
    public class UnitOfWork<IN, OUT>
    {
        private const string defaultUnitOfWorkName = "UnitOfWork";


        #region Members


        protected Dictionary<UnitType, Stopwatch> stopWatch { get; set; }
        protected Exception exception { get; set; }
        protected List<ILogger> Loggers { get; set; } = new List<ILogger>();


        #endregion Members        


        #region Properties
        private string CallerMethodName { get; set; }
        private int CallerLineNumber { get; set; }
        private string CallerFilePath { get; set; }
        public string UnitOfWorkName { get; set; } = defaultUnitOfWorkName;
        private string MethodName { get; set; }
        public bool UseStopwatch { get; set; } = true;
        public bool UseTryCatch { get; set; } = true;
        public bool RethrowExceptions { get; set; } = true;


        //private get below to prevent the developer using this to bypass the operational logic of the execute method, thereby negating the intension of this completely.
        public List<Func<IN, OUT>> Functions { private get; set; } = new List<Func<IN, OUT>>();
        public Func<IN, OUT> Function { private get; set; }
        public List<IN> Inputs { get; private set; }
        public List<OUT> Outputs { get; private set; }


        #endregion Properties


        #region Constructors


        public UnitOfWork(
            Func<IN, OUT> function,
            string unitOfWorkName = defaultUnitOfWorkName,
            bool useStopwatch = true,
            bool useTryCatch = true,
            bool rethrowExceptions = true,
            ILogger logger = null)
            : this(new Func<IN, OUT>[] { function }, unitOfWorkName, useStopwatch, useTryCatch, rethrowExceptions, logger, true) { }


        public UnitOfWork(
            Func<IN, OUT>[] functions,
            string unitOfWorkName = defaultUnitOfWorkName,
            bool useStopwatch = true,
            bool useTryCatch = true,
            bool rethrowExceptions = true,
            ILogger logger = null,
            bool uniqueSignaturePurposesOnly = true)
        {
            //the uniqueSignaturePurposesOnly parameter is only there to make this constructor have a unique signature, and can be ignored as it is not used.
            if (functions == null || functions.Length == 0)
            {
                throw new ArgumentException("The value of functions can not be null or empty!");
            }
            InitParameters();
            InitStopwatch();
            InitLoggers();


            void InitParameters()
            {
                Function = functions[0];
                AddFunction(functions);
                UnitOfWorkName = unitOfWorkName ?? defaultUnitOfWorkName;
                //if the parameter was null, then perhaps it was set in the constructor already, else use the Method name
                MethodName = Function.Method.Name;
                UseStopwatch = useStopwatch;
                UseTryCatch = useTryCatch;
                RethrowExceptions = rethrowExceptions;
            }
            void InitLoggers()
            {
#if DEBUG
                Loggers = new List<ILogger>();
                Loggers.Add(logger ?? new ConsoleLogger());
#endif
                if (logger != null)
                {
                    Loggers = Loggers ?? new List<ILogger>();
                    Loggers.Add(logger);
                }


            }
            void InitStopwatch()
            {
                if (useStopwatch)
                {
                    stopWatch = new Dictionary<UnitType, Stopwatch>();
                    stopWatch.Add(UnitType.UnitOfWork, new Stopwatch());
                    stopWatch.Add(UnitType.Method, new Stopwatch());                  
                }
            }
        }


        #endregion Constructor


        #region Methods        


        public void AddFunction(params Func<IN, OUT>[] functions) => Functions.AddRange(functions);
        public void AddLogger(params ILogger[] loggers) => Loggers.AddRange(loggers);


        public OUT Execute(
            IN input,
            [CallerMemberName] string callerMethodName = "",
            [CallerLineNumber] int callerLineNumber = 0,
            [CallerFilePath] string callerFilePath = ""
            )
        {
            OUT result = default(OUT);
            CallerMethodName = callerMethodName;
            CallerLineNumber = callerLineNumber;
            CallerFilePath = callerFilePath;
            if (Functions.Count > 1)
            {
                Inputs = Inputs ?? new List<IN>();
                Outputs = Outputs ?? new List<OUT>();
            }
            if (UseTryCatch)
            {
                try
                {
                    Run();
                }
                catch (Exception e)
                {
                    ExceptionDispatchInfo.Capture(e);
                    exception = e;
                    Loggers.ForEach(log =>
                        log.WriteError($@"
An ERROR has occurred!
{UnitOfWorkName}-{MethodName}",
Concat($@"
Caller Info:
Method={CallerMethodName}
Line={CallerLineNumber} 
Path={CallerFilePath}
", ((ExceptionManager)exception).ToString())
                        )
                    );
                    if (RethrowExceptions) ExceptionDispatchInfo.Throw(e);
                }
                finally
                {
                    End(UnitType.UnitOfWork);
                }
            }
            else
            {
                Run();
            }
            return result;
            void Run()
            {
                Start(UnitType.UnitOfWork);
                Functions?.ForEach(f =>
                {
                    Function = f;
                    MethodName = f.Method.Name;
                    Start();
                    Inputs?.Add(Clone(input));
                    result = (f != null ? f.Invoke(input) : result);
                    Outputs?.Add(Clone(result));
                    End();
                });
                End(UnitType.UnitOfWork);
            }
        }
        protected virtual void Start(UnitType unitType = UnitType.Method)
        {
            if (!UseStopwatch) return;
            Loggers.ForEach(log =>
                log.WriteInfo(
                    generateSource(unitType),
                    generateMessage(unitType, $"Starting at {System.DateTime.Now.ToString()}!")
                )
            );
            if (stopWatch[unitType].IsRunning) stopWatch[unitType].Reset();
            stopWatch[unitType].Start();            
        }
        protected virtual void End(UnitType unitType = UnitType.Method)
        {
            if (!UseStopwatch) return;
            stopWatch[unitType].Stop();
            Loggers.ForEach(log =>
                log.WriteInfo(
                    generateSource(unitType),
                    generateMessage(unitType, Concat("Ran in ", stopWatch[unitType].ElapsedMilliseconds.ToString(), $"ms. Ending at {System.DateTime.Now.ToString()}!"))
                )
            );
        }


        private string generateSource(UnitType unitType)
        {
            return Concat(unitType.ToString(), "|", unitType == UnitType.UnitOfWork ? UnitOfWorkName : MethodName);
        }
        private string generateMessage(UnitType unitType, string postFix = "")
        {
            return Concat("(", unitType == UnitType.UnitOfWork ? UnitOfWorkName : MethodName, ")", postFix);
        }
        /// <summary>
        /// Perform a deep Copy of the object, using Json as a serialization method. 
        /// NOTE: Private members are not cloned using this method.
        /// Serializable attribute is not required, but if it's an object, the class needs a parameterless constructor.
        /// </summary>
        /// <typeparam name="T">The type of object being copied.</typeparam>
        /// <param name="source">The object instance to copy.</param>
        /// <returns>The copied object.</returns>
        private T Clone<T>(T source)
        {
            var result = default(T);
            var jsonString = "";
            using (var stream = new MemoryStream())
            {
                var serializer = new DataContractJsonSerializer(typeof(T));
                serializer.WriteObject(stream, source);
                byte[] json = stream.ToArray();
                jsonString = Encoding.UTF8.GetString(json, 0, json.Length);
            }
            using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(jsonString)))
            {
                var serializer = new DataContractJsonSerializer(typeof(T));
                result = (T)serializer.ReadObject(stream);
            }
            return result;
        }


        #endregion Methods


        #region Cast Operators


        public static explicit operator Func<IN, OUT>(UnitOfWork<IN, OUT> unitOfWork)
            => unitOfWork.Function;
        public static explicit operator List<Func<IN, OUT>>(UnitOfWork<IN, OUT> unitOfWork)
            => unitOfWork.Functions;
        public static explicit operator UnitOfWork<IN, OUT>(List<Func<IN, OUT>> functions)
            => new UnitOfWork<IN, OUT>(functions.ToArray());
        public static explicit operator UnitOfWork<IN, OUT>(Func<IN, OUT> function)
            => new UnitOfWork<IN, OUT>(function);


        #endregion Cast Operators
    }


    public enum UnitType
    {
        Method,
        UnitOfWork
    }
    public static class Extender
    {
        public static void ExecuteTransaction(this System.Data.IDbConnection connection, params System.Data.IDbCommand[] commands)
        {
            using (connection)
            {
                if (connection.State != System.Data.ConnectionState.Open) connection.Open();
                using (var transaction = connection.BeginTransaction())
                {
                    try
                    {
                        foreach (var command in commands)
                        {
                            command.ExecuteNonQuery();
                        }
                        transaction.Commit();
                    }
                    catch
                    {
                        transaction.Rollback();
                    }
                }
            }
        }
        public static OUT Execute<IN, OUT>(this IN toThat,
            bool useTryCatch = true,
            params Func<IN, OUT>[] doThis)
        {
            var result = default(OUT);
            if (toThat == null && doThis == null) return result;
            if (useTryCatch)
            {
                try
                {
                    foreach (var function in doThis)
                    {
                        result = function(toThat);
                    }
                }
                catch
                {
                    throw;
                }
            }
            else
            {
                foreach (var function in doThis)
                {
                    result = function(toThat);
                }
            }
            return result;
        }


        public static void With<T>(this T toThat, Action<T> doThis) where T : class
            => doThis?.Invoke(toThat);
        public static OUT With<IN, OUT>(this IN toThat, Func<IN, OUT> doThis)
            => doThis.Invoke(toThat);
    }


    #region EventViewerLogger


    /// <summary>
    /// You need the .NET Core compatibility nuget package, if you use this in .NET Core, to write to the EventViewer.
    /// Search NuGet for package named Microsoft.Windows.Compatibility.
    /// This could have been accomplished via a delegate too, but that would add overhead,
    /// and if this used enterprise wide, that's the LAST thing we want.
    /// </summary>
    public class EventViewerLogger : ILogger
    {
        public EventViewerLogger() { }
        public virtual void WriteInfo(string source, string message)
        {
            EventLog.WriteEntry(source, message);
        }
        public virtual void WriteError(string source, string message)
        {
            EventLog.WriteEntry(source, message);
        }
    }


    #endregion EventViewerLogger


    #region ConsoleLogger
    public class ConsoleLogger : ILogger
    {
        public ConsoleLogger() { }
        public virtual void WriteInfo(string source, string message)
        {
            WriteLine(source + "-" + message);
        }
        public virtual void WriteError(string source, string message)
        {
            WriteLine(source + "-" + message);
        }
    }


    #endregion ConsoleLogger


    #region ILogger


    /// <summary>
    /// To implement your own logger, implement this interface.  
    /// </summary>
    public interface ILogger
    {
        void WriteInfo(string source, string message);
        void WriteError(string source, string message);
    }


    #endregion ILogger


    public struct ExceptionManager
    {
        private Exception exception;
        private ExceptionManager(Exception exception)
        {
            this.exception = exception;
        }


        public override string ToString()
        {
            var sb = new StringBuilder();
            sb.Append("**********\n");
            do
            {
                sb.Append($"Message:{exception.Message}");
                sb.Append($"\nSource:{exception.Source}");
                sb.Append($"\nTargetSite:{exception.TargetSite}");
                sb.Append($"\nStackTrace:{exception.StackTrace}");
                sb.Append($"\nHelpLink:{exception.HelpLink}");
                exception = exception.InnerException;
                if (exception != null) sb.Append("\n----------");
            } while (exception != null);
            sb.Append("\n**********\n");
            return sb.ToString();
        }
        public static explicit operator Exception(ExceptionManager exceptionManager)
        {
            return exceptionManager.exception;
        }
        public static explicit operator ExceptionManager(Exception exception)
        {
            return new ExceptionManager(exception);
        }
        public static explicit operator string(ExceptionManager exceptionManager)
        {
            return exceptionManager.ToString();
        }
    }
}