Migrated 'Diagnostics' namespace.

Author: Whathecode

src/Whathecode.System/Diagnostics/Extensions/Extensions.IEnumerable.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+
+
+namespace Whathecode.System.Diagnostics.Extensions
+{
+	public static class Extensions
+	{
+		/// <summary>
+		/// Returns all elements on which a performed action throws an exception.
+		/// </summary>
+		/// <typeparam name = "T">The type of the elements of the input sequence.</typeparam>
+		/// <param name = "source">The source for this extension method.</param>
+		/// <param name = "action">The action to verify whether it throws an exception.</param>
+		/// <param name = "exceptionType">When not null, a specific exception type to look for.</param>
+		/// <returns>A sequence of all elements on which the performed action threw an exception.</returns>
+		public static IEnumerable<T> ThrowsException<T>( this IEnumerable<T> source, Action<T> action, Type exceptionType = null )
+		{
+			if ( exceptionType != null && !typeof( Exception ).GetTypeInfo().IsAssignableFrom( exceptionType ) )
+			{
+				throw new ArgumentException( "The specified exception type is not an Exception." );
+			}
+
+			using ( IEnumerator<T> iterator = source.GetEnumerator() )
+			{
+				while ( iterator.MoveNext() )
+				{
+					bool threwException = false;
+					try
+					{
+						action( iterator.Current );
+					}
+					catch ( Exception e )
+					{
+						if ( exceptionType == null || exceptionType.GetTypeInfo().IsAssignableFrom( e.GetType() ) )
+						{
+							threwException = true;
+						}
+					}
+
+					if ( threwException )
+					{
+						yield return iterator.Current;
+					}
+				}
+			}
+		}
+	}
+}

src/Whathecode.System/Diagnostics/RunTime.cs

@@ -0,0 +1,79 @@
+using System;
+using Whathecode.System.Algorithm;
+
+
+namespace Whathecode.System.Diagnostics
+{
+	/// <summary>
+	/// Class which measures the runtime of a given action.
+	/// </summary>
+	/// <remarks>
+	/// Useful when used as follows:
+	/// var measure = RunTime.From( "Time measure", () =>
+	/// {
+	///   ... statements to execute ...
+	/// } );
+	/// </remarks>
+	public class RunTime
+	{
+		/// <summary>
+		/// Get the time measurement from a given action.
+		/// </summary>
+		/// <param name = "action">The action to measure the time from.</param>
+		/// <returns>The time measurement of the action.</returns>
+		public static StatisticsStopwatch.Measurement From( Action action )
+		{
+			if ( action == null )
+			{
+				throw new ArgumentNullException( nameof( action ) );
+			}
+
+			return From( "", action );
+		}
+
+		/// <summary>
+		/// Get the time measurement from a given action.
+		/// </summary>
+		/// <param name = "label">The label to indicate which measurement it is upon calling ToString() on the result.</param>
+		/// <param name = "action">The action to measure the time from.</param>
+		/// <returns>The time measurement of the action.</returns>
+		public static StatisticsStopwatch.Measurement From( string label, Action action )
+		{
+			if ( action == null )
+			{
+				throw new ArgumentNullException( nameof( action ) );
+			}
+
+			return From( label, action, 1 );
+		}
+
+		/// <summary>
+		/// Get the time measurement of a certain action executed an amount of times.
+		/// </summary>
+		/// <param name = "label">The label to indicate which measurement it is upon calling ToString().</param>
+		/// <param name = "action">The action to measure the time from.</param>
+		/// <param name = "times">The amount of times the action should run.</param>
+		/// <returns>The time measurement of the executed actions.</returns>
+		public static StatisticsStopwatch.Measurement From( string label, Action action, int times )
+		{
+			if ( action == null )
+			{
+				throw new ArgumentNullException( nameof( action ) );
+			}
+			if ( times < 0 )
+			{
+				throw new ArgumentOutOfRangeException( nameof( times ), "Should be greater than zero." );
+			}
+
+			StatisticsStopwatch stopwatch = null;
+			Loop loop = Loop.NumberOfTimes( times, action );
+
+			// Start a new measurement every iteration.
+			loop.Before.First( () => stopwatch = StatisticsStopwatch.Start( label ) );
+			loop.After.AllButLast( () => stopwatch.StartNextMeasurement() );
+			loop.Run();
+
+			return stopwatch.Stop();
+		}
+	}
+}

src/Whathecode.System/Diagnostics/StatisticsStopwatch.Measurement.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+
+namespace Whathecode.System.Diagnostics
+{
+	public partial class StatisticsStopwatch
+	{
+		/// <summary>
+		/// Measured results from StatisticsStopwatch.
+		/// </summary>
+		public class Measurement
+		{
+			readonly DateTime _start;
+			readonly DateTime _stop;
+
+			readonly string _label;
+
+			/// <summary>
+			/// The total amount of time during which measurements were made.
+			/// </summary>
+			public TimeSpan TotalInterval { get; private set; }
+
+			/// <summary>
+			/// The amount of measurements made.
+			/// </summary>
+			public int MeasurementCount { get; private set; }
+
+			/// <summary>
+			/// The average time of the measurements.
+			/// </summary>
+			public TimeSpan AverageTime { get; private set; }
+
+			/// <summary>
+			/// The average time of the measurements, not including the first measurement.
+			/// This is useful when the first call takes more time than sequential calls. (E.g. caching)
+			/// </summary>
+			public TimeSpan AverageTimeFirstExcluded { get; private set; }
+
+			/// <summary>
+			/// The total time of all the measurements.
+			/// </summary>
+			public TimeSpan TotalTime { get; private set; }
+
+
+			/// <summary>
+			/// Specify a new measurement.
+			/// </summary>
+			/// <param name = "label">The label to use for this measurement when ToString() is used.</param>
+			/// <param name = "start">Start time of the measurement.</param>
+			/// <param name = "stop">End time of the measurement.</param>
+			/// <param name = "intervals">The different measured intervals.</param>
+			public Measurement( string label, DateTime start, DateTime stop, List<TimeSpan> intervals )
+			{
+				if ( stop < start )
+				{
+					throw new ArgumentException( "The end time of the measurement should lie after the start time." );
+				}
+
+				_start = start;
+				_stop = stop;
+				_label = label;
+
+				TotalInterval = _stop - _start;
+				MeasurementCount = intervals.Count;
+
+				// Get total time.
+				long totalTicks = intervals.Sum( interval => interval.Ticks );
+				TotalTime = new TimeSpan( totalTicks );
+
+				// Get average times.
+				TimeSpan noTime = new TimeSpan( 0 );
+				if ( intervals.Count > 0 )
+				{
+					AverageTime = new TimeSpan( totalTicks / intervals.Count );
+					AverageTimeFirstExcluded = intervals.Count > 1
+						? new TimeSpan( (TotalTime.Ticks - intervals[ 0 ].Ticks) / (intervals.Count - 1) )
+						: noTime;
+				}
+				else
+				{
+					AverageTime = noTime;
+					AverageTimeFirstExcluded = noTime;
+				}
+			}
+
+
+			public override string ToString()
+			{
+				string output = _label + ": " + AverageTime.TotalMilliseconds + "ms";
+
+				if ( MeasurementCount > 1 )
+				{
+					output += " average time of " + MeasurementCount + " executions.";
+
+					// Check for big difference when not including first measurement.
+					if ( Math.Abs( AverageTime.Ticks - AverageTimeFirstExcluded.Ticks ) > AverageTimeFirstExcluded.Ticks )
+					{
+						output += " (" + AverageTimeFirstExcluded.TotalMilliseconds + "ms when excluding first call)";
+					}
+				}
+
+				return output;
+			}
+		}
+	}
+}

src/Whathecode.System/Diagnostics/StatisticsStopwatch.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+
+namespace Whathecode.System.Diagnostics
+{
+	/// <summary>
+	/// A stopwatch which can give additional statistics for timed intervals.
+	/// </summary>
+	public partial class StatisticsStopwatch
+	{
+		readonly Stopwatch _stopwatch = new Stopwatch();
+		readonly DateTime _timingStart;
+		readonly List<TimeSpan> _intervals = new List<TimeSpan>();
+
+		readonly string _label;
+
+
+		StatisticsStopwatch( DateTime start, string label )
+		{
+			_stopwatch.Start();
+			_timingStart = start;
+
+			_label = label;
+		}
+
+
+		public static StatisticsStopwatch Start()
+		{
+			return Start( "" );
+		}
+
+		public static StatisticsStopwatch Start( string label )
+		{
+			if ( label == null )
+			{
+				throw new ArgumentNullException( nameof( label ) );
+			}
+
+			return new StatisticsStopwatch( DateTime.Now, label );
+		}
+
+		public void StartNextMeasurement()
+		{
+			// Make sure no previous measurement is running.
+			StopCurrentMeasurement();
+
+			// Start new measurement.
+			_stopwatch.Restart();
+		}
+
+		void StopCurrentMeasurement()
+		{
+			if ( _stopwatch.IsRunning )
+			{
+				_stopwatch.Stop();
+
+				// Add new interval.
+				_intervals.Add( new TimeSpan( _stopwatch.ElapsedTicks ) );
+			}
+		}
+
+		public Measurement Stop()
+		{
+			DateTime timingStop = DateTime.Now;
+
+			// When a previous measurement was still running, stop it first and add interval.
+			StopCurrentMeasurement();
+
+			// Return latest updated measurement.            
+			return new Measurement( _label, _timingStart, timingStop, _intervals );
+		}
+	}
+}