Migrated final classes which work for .NET Standard 1.6 from FCL extension library.

Author: Whathecode

src/Whathecode.System/Arithmetic/RateOfChange.cs

@@ -0,0 +1,85 @@
+using System;
+using System.Linq;
+using Whathecode.System.Collections.Generic;
+using Whathecode.System.Operators;
+
+
+namespace Whathecode.System.Arithmetic
+{
+	/// <summary>
+	/// Class which allows to calculate the rate of change of a certain value over a certain interval. (E.g., velocity)
+	/// </summary>
+	/// <typeparam name = "TValue">The type of the value for which the rate of change is calculated.</typeparam>
+	/// <typeparam name = "TOver">The type of the dimension of the interval over which the rate of change is calculated.</typeparam>
+	public class RateOfChange<TValue, TOver>
+		where TOver : IComparable<TOver>
+	{
+		/// <summary>
+		/// The interval over which the rate of change should be calculated.
+		/// </summary>
+		public TOver Interval { get; private set; }
+
+		readonly TupleList<TValue, TOver> _samples = new TupleList<TValue, TOver>();
+
+
+		/// <summary>
+		/// Create a new instance which allows calculating the rate of change.
+		/// </summary>
+		/// <param name = "interval">The interval over which the rate of change should be calculated.</param>
+		public RateOfChange( TOver interval )
+		{
+			Interval = interval;
+		}
+
+
+		/// <summary>
+		/// Add a new sample of a value at a given position.
+		/// </summary>
+		/// <param name = "sample">The value.</param>
+		/// <param name = "at">The position of the value.</param>
+		public void AddSample( TValue sample, TOver at )
+		{
+			if ( _samples.Count > 0 && at.CompareTo( _samples.Last().Item2 ) < 0 )
+			{
+				throw new ArgumentException( "Samples are required to be added in order.", "at" );
+			}
+
+			_samples.Add( sample, at );
+
+			// Clean up samples older than the specified interval.
+			// TODO: This LINQ query probably isn't optimized for lists. What's the performance impact?
+			if ( _samples.Count > 2 )
+			{
+				var toRemove = _samples
+					.Reverse<Tuple<TValue, TOver>>()
+					.Skip( 2 )
+					.SkipWhile( s => Operator<TOver>.Subtract( at, s.Item2 ).CompareTo( Interval ) <= 0 )
+					.ToList();
+				toRemove.ForEach( r => _samples.Remove( r ) );
+			}
+		}
+
+		/// <summary>
+		/// Calculate the rate of change based on the samples currently added.
+		/// </summary>
+		/// <returns>
+		/// The rate of change of the passed values, calculated over the indicated interval.
+		/// If no samples are available, the rate of change is considered to be 0.
+		/// </returns>
+		public TValue GetCurrentRateOfChange()
+		{
+			if ( _samples.Count == 0 )
+			{
+				return CastOperator<double, TValue>.Cast( 0 );
+			}
+
+			Tuple<TValue, TOver> first = _samples.First();
+			Tuple<TValue, TOver> last = _samples.Last();
+
+			double valueDiff = CastOperator<TValue, double>.Cast( Operator<TValue>.Subtract( last.Item1, first.Item1 ) );
+			double overDiff = CastOperator<TOver, double>.Cast( Operator<TOver>.Subtract( last.Item2, first.Item2 ) );
+
+			return CastOperator<double, TValue>.Cast( valueDiff / overDiff );
+		}
+	}
+}

src/Whathecode.System/EnumHelper.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using Whathecode.System.Reflection.Extensions;
+
+
+namespace Whathecode.System
+{
+	/// <summary>
+	/// A generic helper class to do common <see cref="Enum">Enum</see> operations.
+	/// </summary>
+	/// <typeparam name = "T">The type of the enum.</typeparam>
+	public static class EnumHelper<T>
+	{
+		/// <summary>
+		/// Converts the string representation of the name or numeric value of one or more enumerated constants (seperated by comma)
+		/// to an equivalent enumerated object. A parameter specifies whether the operation is case-sensitive.
+		/// </summary>
+		/// <param name = "value">A string containing the name or value to convert.</param>
+		/// <param name = "ignoreCase">True to ignore case; false to regard case.</param>
+		public static T Parse( string value, bool ignoreCase = false )
+		{
+			return (T)Enum.Parse( typeof( T ), value, ignoreCase );
+		}
+
+		/// <summary>
+		/// Retrieves an enumerator of the constants in a specified enumeration.
+		/// </summary>
+		/// <returns>Enumerable which can be used to enumerate over all constants in the specified enumeration.</returns>
+		public static IEnumerable<T> GetValues()
+		{
+			return from object value in Enum.GetValues( typeof( T ) )
+				select (T)value;
+		}
+
+		/// <summary>
+		/// Retrieves an enumerator of all the flagged values in a flags enum.
+		/// </summary>
+		/// <param name = "flags">The value specifying the flags.</param>
+		/// <returns>Enumerable which can be used to enumerate over all flagged values of the passed enum value.</returns>
+		public static IEnumerable<T> GetFlaggedValues( T flags )
+		{
+			if ( !typeof( T ).GetTypeInfo().IsFlagsEnum() )
+			{
+				throw new ArgumentException( "The passed enum is not a flags enum.", nameof( flags ) );
+			}
+			if ( flags == null )
+			{
+				throw new ArgumentNullException( nameof( flags ) );
+			}
+
+			// ReSharper disable PossibleNullReferenceException
+			return from Enum value in Enum.GetValues( typeof( T ) )
+				   where (flags as Enum).HasFlag( value )
+				   select (T)(object)value;
+			// ReSharper restore PossibleNullReferenceException
+		}
+
+		/// <summary>
+		/// Converts an enum of one type to an enum of another type, using a mapping between both.
+		/// TODO: Support flags enums?
+		/// </summary>
+		/// <typeparam name = "TTargetEnum">The target enum type.</typeparam>
+		/// <param name = "value">The value to map to the other enum type.</param>
+		/// <param name = "conversionMapping">Dictionary which is used to map values from one enum type to the other.</param>
+		/// <returns>The passed value, mapped to the desired target enum type.</returns>
+		public static TTargetEnum Convert<TTargetEnum>( T value, IDictionary<T, TTargetEnum> conversionMapping )
+		{
+			if ( !typeof( T ).GetTypeInfo().IsEnum || !typeof( TTargetEnum ).GetTypeInfo().IsEnum )
+			{
+				throw new ArgumentException( "The passed value and target type should be enum types." );
+			}
+
+			// ReSharper disable PossibleNullReferenceException
+			// ReSharper disable AssignNullToNotNullAttribute
+			return conversionMapping.First( pair => (value as Enum).HasFlag( pair.Key as Enum ) ).Value;
+			// ReSharper restore AssignNullToNotNullAttribute
+			// ReSharper restore PossibleNullReferenceException
+		}
+	}
+}

src/Whathecode.System/IO/PathHelper.cs

@@ -0,0 +1,36 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+
+namespace Whathecode.System.IO
+{
+	/// <summary>
+	/// A helper class for <see cref="Path" /> operations.
+	/// </summary>
+	public static class PathHelper
+	{
+		/// <summary>
+		/// Replaces all invalid characters in a given path with a specified character.
+		/// </summary>
+		/// <param name = "path">The path to validate and adjust.</param>
+		/// <param name = "validChar">The character to replace invalid characters with.</param>
+		/// <returns>The original passed path, with all invalid characters replaced by the given character.</returns>
+		/// <exception cref="ArgumentException">Thrown when validChar isn't a valid path character.</exception>
+		public static string ReplaceInvalidChars( string path, char validChar )
+		{
+			// TODO: Separate invalid path chars from invalid filename chars?
+			var invalidChars = Path.GetInvalidPathChars().Concat( Path.GetInvalidFileNameChars() );
+
+			if ( invalidChars.Contains( validChar ) )
+			{
+				throw new ArgumentException( "The passed replacement character 'validChar' should be a valid path character." );
+			}
+
+			string charsString = invalidChars.Select( c => c.ToString() ).Aggregate( (a, b) => a + b );
+			string regexMatchAnyChar = "[" + Regex.Escape( charsString ) + "]";
+			return Regex.Replace( path, regexMatchAnyChar, validChar.ToString() );
+		}
+	}
+}

src/Whathecode.System/MathHelper.cs

@@ -0,0 +1,36 @@
+using System;
+using Whathecode.System.Operators;
+
+
+namespace Whathecode.System
+{
+	/// <summary>
+	/// A helper class to do common <see cref="Math" /> operations.
+	/// </summary>
+	public static class MathHelper
+	{
+		public static double RadiansToDegrees( double radians )
+		{
+			return radians * (180 / Math.PI);
+		}
+
+		public static double DegreesToRadians( double degrees )
+		{
+			return degrees * (Math.PI / 180);
+		}
+
+		/// <summary>
+		/// Round a value to the nearest multiple of another value.
+		/// </summary>
+		/// <typeparam name = "T">The type of the value.</typeparam>
+		/// <param name = "value">The value to round to the nearest multiple.</param>
+		/// <param name = "roundToMultiple">The passed value will be rounded to the nearest multiple of this value.</param>
+		/// <returns>A multiple of roundToMultiple, nearest to the passed value.</returns>
+		public static T RoundToNearest<T>( T value, T roundToMultiple )
+		{
+			double factor = CastOperator<T, double>.Cast( roundToMultiple );
+			double result = Math.Round( CastOperator<T, double>.Cast( value ) / factor ) * factor;
+			return CastOperator<double, T>.Cast( result );
+		}
+	}
+}

src/Whathecode.System/Reflection/Expressions/GetterExpression.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Linq.Expressions;
+using System.Reflection;
+
+
+namespace Whathecode.System.Reflection.Expressions
+{
+	/// <summary>
+	/// An expression from which open instance and closed instance getters for fields and properties can be created.
+	/// </summary>
+	/// <typeparam name = "T">The type of the field or property.</typeparam>
+	public class GetterExpression<T>
+	{
+		ParameterExpression _instance;
+		string _memberName;
+
+
+		public GetterExpression( FieldInfo field )
+		{
+			_instance = Expression.Parameter( field.DeclaringType );
+			_memberName = field.Name;
+		}
+
+		public GetterExpression( PropertyInfo property )
+		{
+			_instance = Expression.Parameter( property.DeclaringType );
+			_memberName = property.Name;
+		}
+
+
+		/// <summary>
+		/// Creates a delegate of a specified type that retrieves the value of this getter of an instance passed as parameter.
+		/// </summary>
+		/// <typeparam name = "TInstance">The type of the instance.</typeparam>
+		/// <returns>A delegate which can be used to retrieve the value of this getter of a passed instance.</returns>
+		public Func<TInstance, T> OpenInstance<TInstance>()
+		{
+			return Expression.Lambda<Func<TInstance, T>>( Expression.PropertyOrField( _instance, _memberName ), _instance ).Compile();
+		}
+
+		/// <summary>
+		/// Creates a delegate of a specified type that retrieves the value of this getter of an instance.
+		/// </summary>
+		/// <param name  ="instance">The instance from which to get the value.</param>
+		/// <returns>A delegate which can be used to retrieve the value of this getter of the passed instance.</returns>
+		public Func<T> ClosedOver<TInstance>( TInstance instance )
+		{
+			var constantInstance = Expression.Constant( instance );
+			return Expression.Lambda<Func<T>>( Expression.PropertyOrField( constantInstance, _memberName ) ).Compile();
+		}
+	}
+}