Added extension methods from old FCL.

Author: Whathecode

src/Whathecode.System/Extensions/Extensions.Array.cs

@@ -0,0 +1,19 @@
+using Whathecode.System.Arithmetic.Range;
+
+
+namespace Whathecode.System.Extensions
+{
+	public static partial class Extensions
+	{
+		/// <summary>
+		/// Returns the interval of the indices.
+		/// </summary>
+		/// <typeparam name = "T">Type of the values in the array.</typeparam>
+		/// <param name = "source">The source for this extension method.</param>
+		/// <returns>The interval of the indices of the array.</returns>
+		public static Interval<int> GetIndexInterval<T>( this T[] source )
+		{
+			return new Interval<int>( 0, source.Length - 1 );
+		}
+	}
+}

src/Whathecode.System/Extensions/Extensions.DateTime.cs

@@ -0,0 +1,99 @@
+using System;
+
+
+namespace Whathecode.System.Extensions
+{
+	public static partial class Extensions
+	{
+		/// <summary>
+		/// Returns part of the <see cref="DateTime" /> object.
+		/// </summary>
+		/// <param name = "source">The <see cref="DateTime" /> to retrieve a part from.</param>
+		/// <param name = "part">Which part of the <see cref="DateTime" /> to retrieve.</param>
+		public static double GetDateTimePart( this DateTime source, DateTimePart part )
+		{
+			switch ( part )
+			{
+				case DateTimePart.Day:
+					return source.Day;
+				case DateTimePart.Hour:
+					return source.Hour;
+				case DateTimePart.Millisecond:
+					return source.Millisecond;
+				case DateTimePart.Minute:
+					return source.Minute;
+				case DateTimePart.Month:
+					return source.Month;
+				case DateTimePart.Second:
+					return source.Second;
+				case DateTimePart.Year:
+					return source.Year;
+			}
+
+			throw new NotSupportedException();
+		}
+
+		/// <summary>
+		/// Returns a new <see cref="DateTime" /> object which is rounded down to the specified <paramref name="part" />.
+		/// </summary>
+		/// <param name = "source">The <see cref="DateTime" /> to round down.</param>
+		/// <param name = "part">The part to round down to.</param>
+		public static DateTime Round( this DateTime source, DateTimePart part )
+		{
+			return new DateTime(
+				source.Year,
+				part >= DateTimePart.Month ? source.Month : 1,
+				part >= DateTimePart.Day ? source.Day : 1,
+				part >= DateTimePart.Hour ? source.Hour : 0,
+				part >= DateTimePart.Minute ? source.Minute : 0,
+				part >= DateTimePart.Second ? source.Second : 0,
+				part >= DateTimePart.Millisecond ? source.Millisecond : 0 );
+		}
+
+		/// <summary>
+		/// Returns a new <see cref="DateTime" /> object which is rounded down to the day indicating the start of the week.
+		/// </summary>
+		/// <param name = "source">The <see cref="DateTime" /> to round down.</param>
+		/// <param name = "startOfWeek">They day of the week to round down to.</param>
+		public static DateTime Round( this DateTime source, DayOfWeek startOfWeek )
+		{
+			int excessDays = source.DayOfWeek - startOfWeek;
+			if ( excessDays < 0 )
+			{
+				excessDays += 7;
+			}
+
+			return source.Date - TimeSpan.FromDays( excessDays );
+		}
+
+		/// <summary>
+		/// Safely subtract a given timespan from a <see cref="DateTime" />, preventing an <see cref="ArgumentOutOfRangeException" /> from occurring.
+		/// When the subtraction results in an invalid <see cref="DateTime" />, the nearest valid <see cref="DateTime" /> is used.
+		/// </summary>
+		/// <param name = "source">The <see cref="DateTime" /> to subtract from.</param>
+		/// <param name = "time">The amount of time to subtract from the <see cref="DateTime" />.</param>
+		public static DateTime SafeSubtract( this DateTime source, TimeSpan time )
+		{
+			long minTicks = DateTime.MinValue.Ticks;
+
+			return source.Ticks - time.Ticks < minTicks
+				? DateTime.MinValue
+				: source - time;
+		}
+
+		/// <summary>
+		/// Safely add a given timespan to a <see cref="DateTime" />, preventing an <see cref="ArgumentOutOfRangeException" /> from occurring.
+		/// When the addition results in an invalid <see cref="DateTime" />, the nearest valid <see cref="DateTime" /> is used.
+		/// </summary>
+		/// <param name = "source">The <see cref="DateTime" /> to add to.</param>
+		/// <param name = "time">The amount of time to add to the <see cref="DateTime" />.</param>
+		public static DateTime SafeAdd( this DateTime source, TimeSpan time )
+		{
+			long maxTicks = DateTime.MaxValue.Ticks;
+
+			return source.Ticks + time.Ticks > maxTicks
+				? DateTime.MaxValue
+				: source + time;
+		}
+	}
+}

src/Whathecode.System/Extensions/Extensions.Dictionary.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+
+
+namespace Whathecode.System.Extensions
+{
+	public static partial class Extensions
+	{
+		/// <summary>
+		/// Gets the value associated with the specified key and passes it to delegate which can use it.
+		/// </summary>
+		/// <typeparam name = "TKey">The type of the keys in the dictionary.</typeparam>
+		/// <typeparam name = "TValue">The type of the values in the dictionary.</typeparam>
+		/// <param name = "source">The source for this extension method.</param>
+		/// <param name = "key">The key of the element to use the value of if it's contained within the dictionary.</param>
+		/// <param name = "useValue">The action to perform with the value if the key is contained within the dictionary.</param>
+		/// <returns>true when the key was present in the dictionary and the action was performed, false otherwise.</returns>
+		public static bool TryUseValue<TKey, TValue>( this Dictionary<TKey, TValue> source, TKey key, Action<TValue> useValue )
+		{
+			TValue value;
+			if ( source.TryGetValue( key, out value ) )
+			{
+				useValue( value );
+
+				return true;
+			}
+
+			return false;
+		}
+
+		/// <summary>
+		/// Adds/updates or removes a certain key from the dictionary. The key is removed when the value is null.
+		/// </summary>
+		/// <typeparam name = "TKey">The type of the keys in the dictionary.</typeparam>
+		/// <typeparam name = "TValue">The type of the values in the dictionary.</typeparam>
+		/// <param name = "source">The source for this extension method.</param>
+		/// <param name = "key">The key of the element in the dictionary to update.</param>
+		/// <param name = "value">The new value for the key.</param>
+		public static void Update<TKey, TValue>( this Dictionary<TKey, TValue> source, TKey key, TValue value )
+			where TValue : class
+		{
+			if ( source == null || key == null )
+			{
+				throw new ArgumentNullException( "Both source and key should be different from null." );
+			}
+
+			source.Update( key, value, v => v != null );
+		}
+
+		/// <summary>
+		/// Adds/updates or removes a certain key from the dictionary.
+		/// </summary>
+		/// <typeparam name = "TKey">The type of the keys in the dictionary.</typeparam>
+		/// <typeparam name = "TValue">The type of the values in the dictionary.</typeparam>
+		/// <param name = "source">The source for this extension method.</param>
+		/// <param name = "key">The key of the element in the dictionary to update.</param>
+		/// <param name = "value">The new value for the key.</param>
+		/// <param name = "validValue">
+		/// Determines whether or not the new value is a valid value. When it returns true the key is updated with the new value,
+		/// otherwise the key is removed from the dictionary.
+		/// </param>
+		public static void Update<TKey, TValue>( this Dictionary<TKey, TValue> source, TKey key, TValue value, Func<TValue, bool> validValue )
+		{
+			if ( source == null || key == null || validValue == null )
+			{
+				throw new ArgumentNullException( "Both source, key, and validValue should be different from null." );
+			}
+
+			if ( validValue( value ) )
+			{
+				source[ key ] = value;
+			}
+			else
+			{
+				source.Remove( key );
+			}
+		}
+	}
+}

src/Whathecode.System/Extensions/Extensions.DirectoryInfo.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+
+namespace Whathecode.System.Extensions
+{
+	public static partial class Extensions
+	{
+		/// <summary>
+		/// Returns an enumerable collection of file information that matches a regular expression.
+		/// </summary>
+		/// <param name = "directory">The directory to search in.</param>
+		/// <param name = "searchOption">Specifies whether to search in all subdirectories as well.</param>
+		/// <param name = "regexPattern">The regular expression which is used to see whether a file matches.</param>
+		/// <param name = "regexOptions">Options for the regular expression.</param>
+		public static IEnumerable<FileInfo> EnumerateFiles(
+			this DirectoryInfo directory,
+			SearchOption searchOption,
+			string regexPattern,
+			RegexOptions regexOptions = RegexOptions.None )
+		{
+			return directory.EnumerateFiles( "*", searchOption ).Where( file => Regex.IsMatch( file.FullName, regexPattern, regexOptions ) );
+		}
+
+
+		/// <summary>
+		/// Returns the first common subdirectory if any, null otherwise.
+		/// </summary>
+		/// <param name = "source">The source for this extension method.</param>
+		/// <param name = "directory">The directory to check for a common subdirectory.</param>
+		/// <returns>The first common subdirectory if any, null otherwise.</returns>
+		public static DirectoryInfo GetCommonParentDirectory( this DirectoryInfo source, DirectoryInfo directory )
+		{
+			Func<DirectoryInfo, Stack<DirectoryInfo>> getParentDirs = d =>
+			{
+				Stack<DirectoryInfo> sourceParents = new Stack<DirectoryInfo>();
+				while ( d.Parent != null )
+				{
+					sourceParents.Push( d );
+					d = d.Parent;
+				}
+				sourceParents.Push( d );
+				return sourceParents;
+			};
+
+			Stack<DirectoryInfo> parents1 = getParentDirs( source );
+			Stack<DirectoryInfo> parents2 = getParentDirs( directory );
+
+			DirectoryInfo lastMatching = null;
+			while ( parents1.Count > 0 && parents2.Count > 0 )
+			{
+				DirectoryInfo p1 = parents1.Pop();
+				DirectoryInfo p2 = parents2.Pop();
+				if ( p1.FullName == p2.FullName )
+				{
+					lastMatching = p1;
+				}
+				else
+				{
+					break;
+				}
+			}
+
+			return lastMatching;
+		}
+	}
+}

src/Whathecode.System/Extensions/Extensions.IComparable.cs

@@ -0,0 +1,30 @@
+using System;
+
+
+namespace Whathecode.System.Extensions
+{
+	public static partial class Extensions
+	{
+		/// <summary>
+		/// Limit a value to a certain range. When the value is smaller/bigger than the range, snap it to the range border.
+		/// </summary>
+		/// <typeparam name = "T">The type of the value to limit.</typeparam>
+		/// <param name = "source">The source for this extension method.</param>
+		/// <param name = "start">The start of the interval, included in the interval.</param>
+		/// <param name = "end">The end of the interval, included in the interval.</param>
+		/// <returns></returns>
+		public static T Clamp<T>( this T source, T start, T end )
+			where T : IComparable
+		{
+			bool isReversed = start.CompareTo( end ) > 0;
+			T smallest = isReversed ? end : start;
+			T biggest = isReversed ? start : end;
+
+			return source.CompareTo( smallest ) < 0
+				? smallest
+				: source.CompareTo( biggest ) > 0
+					? biggest
+					: source;
+		}
+	}
+}

src/Whathecode.System/Extensions/Extensions.TimeSpan.cs

@@ -0,0 +1,23 @@
+using System;
+
+
+namespace Whathecode.System.Extensions
+{
+	public static partial class Extensions
+	{
+		/// <summary>
+		/// Returns a new <see cref="TimeSpan" /> object which is rounded down to the specified <paramref name="part" />.
+		/// </summary>
+		/// <param name = "source">The <see cref="TimeSpan" /> to round down.</param>
+		/// <param name = "part">The part to round down to.</param>
+		public static TimeSpan Round( this TimeSpan source, TimeSpanPart part )
+		{
+			return new TimeSpan(
+				part >= TimeSpanPart.Day ? source.Days : 0,
+				part >= TimeSpanPart.Hour ? source.Hours : 0,
+				part >= TimeSpanPart.Minute ? source.Minutes : 0,
+				part >= TimeSpanPart.Second ? source.Seconds : 0,
+				part >= TimeSpanPart.Millisecond ? source.Milliseconds : 0 );
+		}
+	}
+}