Remove SerilogTimings and add a benchmark that fit our needs.

VocaluxeLib/Log/CBenchmark.cs

@@ -0,0 +1,165 @@
+using System;
+using System.Diagnostics;
+using VocaluxeLib.Utils;
+
+namespace VocaluxeLib.Log
+{
+    /// <summary>
+    /// Class for Benchmarks.
+    /// Can be used as instance or through the static wrappers.
+    /// </summary>
+    public class CBenchmark : IDisposable
+    {
+        // Pool of stop watches shared between all instances (we can get more than 5 but it only keeps 5)
+        private static readonly CObjectPool<Stopwatch> _WatchesPool = new CObjectPool<Stopwatch>(() => new Stopwatch(), 5);
+        private static readonly double _NanosecPerTick = (1000.0 * 1000.0 * 1000.0) / Stopwatch.Frequency;
+
+        // The stop watch used by this instance
+        private Stopwatch _Watch = null;
+        // The operation name the will be written to the log on events for this instance
+        private readonly string _OperationName;
+
+        /// <summary>
+        /// Creates a new benchmark instance.
+        /// </summary>
+        /// <param name="operationName">The name of the operation (will be used for log messages).</param>
+        public CBenchmark(string operationName)
+        {
+            _OperationName = operationName;
+        }
+
+        /// <summary>
+        /// Starts this benchmark.
+        /// </summary>
+        public void Start()
+        {
+            if (_Watch != null)
+                throw new InvalidOperationException("Timer is already running.");
+            _Watch = _WatchesPool.GetObject();
+            _Watch.Restart();
+            CLog.Information("Started {StartedOperation}", CLog.Params(_OperationName));
+        }
+
+        /// <summary>
+        /// Stops this benchmark.
+        /// </summary>
+        /// <param name="success">If true a success message will be added to the log otherwise a message for failure.</param>
+        public void Stop(bool success = true) 
+        {
+            if (_Watch == null)
+                throw new InvalidOperationException("Timer is not running.");
+            _Watch.Stop();
+            double duration = _GetElapsedTime(_Watch);
+
+            _WatchesPool.PutObject(_Watch);
+            _Watch = null;
+            if (success)
+                CLog.Information("Finished {StartedOperation} successfully in {Duration:#,##0.00}ms", CLog.Params(_OperationName, duration));
+            else
+                CLog.Information("Failed {StartedOperation} in {Duration:#,##0.00}ms", CLog.Params(_OperationName, duration));
+        }
+
+        /// <summary>
+        /// Helper method to extract the elapsed time from a stopwatch.
+        /// </summary>
+        /// <param name="watch">The stopwatch.</param>
+        /// <returns>The elapsed time of the given stop watch.</returns>
+        private double _GetElapsedTime(Stopwatch watch)
+        {
+            if (Stopwatch.IsHighResolution && _NanosecPerTick > 0)
+                return (float)((_NanosecPerTick * watch.ElapsedTicks) / (1000.0 * 1000.0));
+            else
+                return watch.ElapsedMilliseconds;
+        }
+
+        /// <summary>
+        /// Ends a possibly running benchmark (sucessfully).
+        /// </summary>
+        public void Dispose()
+        {
+            if (_Watch != null)
+                Stop();
+        }
+
+        #region Static functions
+
+        /// <summary>
+        /// Logs the time from now to disposal of the returned object.
+        /// </summary>
+        /// <param name="operationName">The name of the operation (will be used for log messages).</param>
+        /// <returns>Object which needs to be disposed to stop the benchmark.</returns>
+        /// <example>
+        /// <code> 
+        /// using(CBenchmark.Time("TestOperation")){
+        ///     //do someting
+        /// }
+        /// </code>
+        /// </example>
+        public static IDisposable Time(string operationName)
+        {
+            CBenchmark benchmark = new CBenchmark(operationName);
+            benchmark.Start();
+            return benchmark;
+        }
+
+        /// <summary>
+        /// Logs the time from now to the call of End() on the returned object (== success) or it's disposal (== failure).
+        /// </summary>
+        /// <param name="operationName">The name of the operation (will be used for log messages).</param>
+        /// <returns>Object to stop the benchmark.</returns>
+        /// <example>
+        /// <code> 
+        /// using(var op = CBenchmark.Begin("TestOperation")){
+        ///     //do someting that could fail
+        ///     op.End();
+        /// }
+        /// </code>
+        /// </example>
+        public static COperation Begin(string operationName)
+        {
+            CBenchmark benchmark = new CBenchmark(operationName);
+            benchmark.Start();
+            return new COperation(benchmark);
+        }
+
+        #region Helper class for operation
+
+        /// <summary>
+        /// Helper object to end a benchmark (End() for success and Dispose() for failure).
+        /// </summary>
+        public class COperation : IDisposable
+        {
+            private readonly CBenchmark _Benchmark;
+
+            /// <summary>
+            /// Creates a new instance of the benchmark helper object.
+            /// </summary>
+            /// <param name="benchmark">The associated benchmark object.</param>
+            internal COperation(CBenchmark benchmark)
+            {
+                _Benchmark = benchmark;
+
+            }
+
+            /// <summary>
+            /// End the associated benchmark sucessfully.
+            /// </summary>
+            public void End()
+            {
+                _Benchmark.Stop(true);
+            }
+
+            /// <summary>
+            /// End the associated benchmark not sucessfully.
+            /// </summary>
+            public void Dispose()
+            {
+                _Benchmark.Stop(false);
+            }
+        }
+
+        #endregion
+
+        #endregion
+    }
+}