X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fclass%2FSystem.Core%2FSystem.Linq%2FEnumerable.cs;h=d2c98d0a1954f16a877a18c2c856d759747d2563;hb=cc2c56a916645e45991c43f86409966218a6a177;hp=d243ff7c327e53b54ab0c76581c67096c7878eae;hpb=fd6bd11aa889f906c3be7f3f1f2893015a8ea808;p=mono.git

diff --git a/mcs/class/System.Core/System.Linq/Enumerable.cs b/mcs/class/System.Core/System.Linq/Enumerable.cs
index d243ff7c327..d2c98d0a195 100644
--- a/mcs/class/System.Core/System.Linq/Enumerable.cs
+++ b/mcs/class/System.Core/System.Linq/Enumerable.cs
@@ -40,6 +40,19 @@ namespace System.Linq
 {
 	public static class Enumerable
 	{
+		enum Fallback {
+			Default,
+			Throw
+		}
+
+		class PredicateOf<T> {
+			public static readonly Func<T, bool> Always = (t) => true;
+		}
+
+		class Function<T> {
+			public static readonly Func<T, T> Identity = (t) => t;
+		}
+
 		#region Aggregate
 
 		public static TSource Aggregate<TSource> (this IEnumerable<TSource> source, Func<TSource, TSource, TSource> func)
@@ -77,8 +90,8 @@ namespace System.Linq
 			if (resultSelector == null)
 				throw new ArgumentNullException ("resultSelector");
 
-			TAccumulate result = seed;
-			foreach (TSource e in source)
+			var result = seed;
+			foreach (var e in source)
 				result = func (result, e);
 
 			return resultSelector (result);
@@ -92,7 +105,7 @@ namespace System.Linq
 		{
 			Check.SourceAndPredicate (source, predicate);
 
-			foreach (TSource element in source)
+			foreach (var element in source)
 				if (!predicate (element))
 					return false;
 
@@ -107,6 +120,10 @@ namespace System.Linq
 		{
 			Check.Source (source);
 
+			var collection = source as ICollection<TSource>;
+			if (collection != null)
+				return collection.Count > 0;
+
 			using (var enumerator = source.GetEnumerator ())
 				return enumerator.MoveNext ();
 		}
@@ -137,35 +154,39 @@ namespace System.Linq
 
 		public static double Average (this IEnumerable<int> source)
 		{
-			return Average (source, (a, b) => a + b, (a, b) => (double) a / (double) b);
+			return Average<int, long, double> (source, (a, b) => a + b, (a, b) => (double) a / (double) b);
 		}
 
 		public static double Average (this IEnumerable<long> source)
 		{
-			return Average (source, (a, b) => a + b, (a, b) => (double) a / (double) b);
+			return Average<long, long, double> (source, (a, b) => a + b, (a, b) => (double) a / (double) b);
 		}
 
 		public static double Average (this IEnumerable<double> source)
 		{
-			return Average (source, (a, b) => a + b, (a, b) => a / b);
+			return Average<double, double, double> (source, (a, b) => a + b, (a, b) => a / b);
 		}
 
 		public static float Average (this IEnumerable<float> source)
 		{
-			return Average (source, (a, b) => a + b, (a, b) => a / b);
+			return Average<float, double, float> (source, (a, b) => a + b, (a, b) => (float) a / (float) b);
 		}
 
 		public static decimal Average (this IEnumerable<decimal> source)
 		{
-			return Average (source, (a, b) => a + b, (a, b) => a / b);
+			return Average<decimal, decimal, decimal> (source, (a, b) => a + b, (a, b) => a / b);
 		}
 
-		static TR Average<TA, TR> (this IEnumerable<TA> source, Func<TA, TA, TA> func, Func<TA, int, TR> result)
+		static TResult Average<TElement, TAggregate, TResult> (this IEnumerable<TElement> source,
+			Func<TAggregate, TElement, TAggregate> func, Func<TAggregate, long, TResult> result)
+			where TElement : struct
+			where TAggregate : struct
+			where TResult : struct
 		{
 			Check.Source (source);
 
-			TA total = default (TA);
-			int counter = 0;
+			var total = default (TAggregate);
+			long counter = 0;
 			foreach (var element in source) {
 				total = func (total, element);
 				++counter;
@@ -177,269 +198,135 @@ namespace System.Linq
 			return result (total, counter);
 		}
 
-		public static double? Average (this IEnumerable<int?> source)
+		static TResult? AverageNullable<TElement, TAggregate, TResult> (this IEnumerable<TElement?> source,
+			Func<TAggregate, TElement, TAggregate> func, Func<TAggregate, long, TResult> result)
+			where TElement : struct
+			where TAggregate : struct
+			where TResult : struct
 		{
 			Check.Source (source);
 
-			bool onlyNull = true;
-			long sum = 0;
+			var total = default (TAggregate);
 			long counter = 0;
-			foreach (int? element in source) {
-				if (element.HasValue) {
-					onlyNull = false;
-					sum += element.Value;
-					counter++;
-				}
+			foreach (var element in source) {
+				if (!element.HasValue)
+					continue;
+
+				total = func (total, element.Value);
+				counter++;
 			}
-			return (onlyNull ? null : (double?) sum / (double?) counter);
+
+			if (counter == 0)
+				return null;
+
+			return new TResult? (result (total, counter));
+		}
+
+		public static double? Average (this IEnumerable<int?> source)
+		{
+			Check.Source (source);
+
+			return source.AverageNullable<int, long, double> ((a, b) => a + b, (a, b) => (double) a / (double) b);
 		}
 
 		public static double? Average (this IEnumerable<long?> source)
 		{
 			Check.Source (source);
 
-			bool onlyNull = true;
-			long sum = 0;
-			long counter = 0;
-			foreach (long? element in source) {
-				if (element.HasValue) {
-					onlyNull = false;
-					sum += element.Value;
-					counter++;
-				}
-			}
-			return (onlyNull ? null : (double?) sum / (double?) counter);
+			return source.AverageNullable<long, long, double> ((a, b) => a + b, (a, b) => (double) a / b);
 		}
 
 		public static double? Average (this IEnumerable<double?> source)
 		{
 			Check.Source (source);
 
-			bool onlyNull = true;
-			double sum = 0;
-			double counter = 0;
-			foreach (double? element in source) {
-				if (element.HasValue) {
-					onlyNull = false;
-					sum += element.Value;
-					counter++;
-				}
-			}
-			return (onlyNull ? null : (double?) (sum / counter));
+			return source.AverageNullable<double, double, double> ((a, b) => a + b, (a, b) => a / b);
 		}
 
 		public static decimal? Average (this IEnumerable<decimal?> source)
 		{
 			Check.Source (source);
 
-			bool onlyNull = true;
-			decimal sum = 0;
-			decimal counter = 0;
-			foreach (decimal? element in source) {
-				if (element.HasValue) {
-					onlyNull = false;
-					sum += element.Value;
-					counter++;
-				}
-			}
-			return (onlyNull ? null : (decimal?) (sum / counter));
+			return source.AverageNullable<decimal, decimal, decimal> ((a, b) => a + b, (a, b) => a / b);
 		}
 
 		public static float? Average (this IEnumerable<float?> source)
 		{
 			Check.Source (source);
 
-			float sum = 0;
-			float counter = 0;
-			foreach (float? element in source) {
-				if (element.HasValue) {
-					sum += element.Value;
-					++counter;
-				}
-			}
-
-			if (counter == 0)
-				return null;
-
-			return sum / counter;
+			return source.AverageNullable<float, double, float> ((a, b) => a + b, (a, b) => (float) a / (float) b);
 		}
 
 		public static double Average<TSource> (this IEnumerable<TSource> source, Func<TSource, int> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			long sum = 0;
-			long counter = 0;
-			foreach (TSource item in source) {
-				sum += selector (item);
-				counter++;
-			}
-
-			if (counter == 0)
-				throw new InvalidOperationException ();
-			else
-				return (double) sum / (double) counter;
+			return source.Select (selector).Average<int, long, double> ((a, b) => a + b, (a, b) => (double) a / (double) b);
 		}
 
 		public static double? Average<TSource> (this IEnumerable<TSource> source, Func<TSource, int?> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			bool onlyNull = true;
-			long sum = 0;
-			long counter = 0;
-			foreach (TSource item in source) {
-				int? element = selector (item);
-				if (element.HasValue) {
-					onlyNull = false;
-					sum += element.Value;
-					counter++;
-				}
-			}
-			return (onlyNull ? null : (double?) sum / (double?) counter);
+			return source.Select (selector).AverageNullable<int, long, double> ((a, b) => a + b, (a, b) => (double) a / (double) b);
 		}
 
 		public static double Average<TSource> (this IEnumerable<TSource> source, Func<TSource, long> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			long sum = 0;
-			long counter = 0;
-			foreach (TSource item in source) {
-				sum += selector (item);
-				counter++;
-			}
-
-			if (counter == 0)
-				throw new InvalidOperationException ();
-			else
-				return (double) sum / (double) counter;
+			return source.Select (selector).Average<long, long, double> ((a, b) => a + b, (a, b) => (double) a / (double) b);
 		}
 
 		public static double? Average<TSource> (this IEnumerable<TSource> source, Func<TSource, long?> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			bool onlyNull = true;
-			long sum = 0;
-			long counter = 0;
-			foreach (TSource item in source) {
-				long? element = selector (item);
-				if (element.HasValue) {
-					onlyNull = false;
-					sum += element.Value;
-					counter++;
-				}
-			}
-			return (onlyNull ? null : (double?) sum / (double?) counter);
+			return source.Select (selector).AverageNullable<long, long, double> ((a, b) => a + b, (a, b) => (double) a / (double) b);
 		}
 
 		public static double Average<TSource> (this IEnumerable<TSource> source, Func<TSource, double> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			double sum = 0;
-			double counter = 0;
-			foreach (TSource item in source) {
-				sum += selector (item);
-				counter++;
-			}
-
-			if (counter == 0)
-				throw new InvalidOperationException ();
-			else
-				return sum / counter;
+			return source.Select (selector).Average<double, double, double> ((a, b) => a + b, (a, b) => a / b);
 		}
 
 		public static double? Average<TSource> (this IEnumerable<TSource> source, Func<TSource, double?> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			bool onlyNull = true;
-			double sum = 0;
-			double counter = 0;
-			foreach (TSource item in source) {
-				double? element = selector (item);
-				if (element.HasValue) {
-					onlyNull = false;
-					sum += element.Value;
-					counter++;
-				}
-			}
-			return (onlyNull ? null : (double?) (sum / counter));
+			return source.Select (selector).AverageNullable<double, double, double> ((a, b) => a + b, (a, b) => a / b);
 		}
 
 		public static float Average<TSource> (this IEnumerable<TSource> source, Func<TSource, float> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			float sum = 0;
-			float counter = 0;
-			foreach (TSource item in source) {
-				sum += selector (item);
-				++counter;
-			}
-
-			if (counter == 0)
-				throw new InvalidOperationException ();
-
-			return sum / counter;
+			return source.Select (selector).Average<float, double, float> ((a, b) => a + b, (a, b) => (float) a / (float) b);
 		}
 
 		public static float? Average<TSource> (this IEnumerable<TSource> source, Func<TSource, float?> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			float sum = 0;
-			float counter = 0;
-			foreach (TSource item in source) {
-				float? value = selector (item);
-				if (value.HasValue) {
-					sum  += value.Value;
-					++counter;
-				}
-			}
-
-			if (counter == 0)
-				throw new InvalidOperationException ();
-
-			return sum / counter;
+			return source.Select (selector).AverageNullable<float, double, float> ((a, b) => a + b, (a, b) => (float) a / (float) b);
 		}
 
 		public static decimal Average<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			decimal sum = 0;
-			decimal counter = 0;
-			foreach (TSource item in source) {
-				sum += selector (item);
-				counter++;
-			}
-
-			if (counter == 0)
-				throw new InvalidOperationException ();
-			else
-				return sum / counter;
+			return source.Select (selector).Average<decimal, decimal, decimal> ((a, b) => a + b, (a, b) => a / b);
 		}
 
 		public static decimal? Average<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal?> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			bool onlyNull = true;
-			decimal sum = 0;
-			decimal counter = 0;
-			foreach (TSource item in source) {
-				decimal? element = selector (item);
-				if (element.HasValue) {
-					onlyNull = false;
-					sum += element.Value;
-					counter++;
-				}
-			}
-			return (onlyNull ? null : (decimal?) (sum / counter));
+			return source.Select (selector).AverageNullable<decimal, decimal, decimal> ((a, b) => a + b, (a, b) => a / b);
 		}
+
 		#endregion
 
 		#region Cast
@@ -453,8 +340,8 @@ namespace System.Linq
 
 		static IEnumerable<TResult> CreateCastIterator<TResult> (IEnumerable source)
 		{
-			foreach (object element in source)
-				yield return (TResult) element;
+			foreach (TResult element in source)
+				yield return element;
 		}
 
 		#endregion
@@ -496,10 +383,9 @@ namespace System.Linq
 			if (comparer == null)
 				comparer = EqualityComparer<TSource>.Default;
 
-			foreach (TSource e in source) {
-				if (comparer.Equals (e, value))
+			foreach (var element in source)
+				if (comparer.Equals (element, value))
 					return true;
-			}
 
 			return false;
 		}
@@ -597,9 +483,25 @@ namespace System.Linq
 
 		#region ElementAt
 
+		static TSource ElementAt<TSource> (this IEnumerable<TSource> source, int index, Fallback fallback)
+		{
+			long counter = 0L;
+
+			foreach (var element in source) {
+				if (index == counter++)
+					return element;
+			}
+
+			if (fallback == Fallback.Throw)
+				throw new ArgumentOutOfRangeException ();
+
+			return default (TSource);
+		}
+
 		public static TSource ElementAt<TSource> (this IEnumerable<TSource> source, int index)
 		{
 			Check.Source (source);
+
 			if (index < 0)
 				throw new ArgumentOutOfRangeException ();
 
@@ -607,14 +509,7 @@ namespace System.Linq
 			if (list != null)
 				return list [index];
 
-			int counter = 0;
-			foreach (var element in source) {
-				if (counter == index)
-					return element;
-				counter++;
-			}
-
-			throw new ArgumentOutOfRangeException ();
+			return source.ElementAt (index, Fallback.Throw);
 		}
 
 		#endregion
@@ -624,6 +519,7 @@ namespace System.Linq
 		public static TSource ElementAtOrDefault<TSource> (this IEnumerable<TSource> source, int index)
 		{
 			Check.Source (source);
+
 			if (index < 0)
 				return default (TSource);
 
@@ -631,14 +527,7 @@ namespace System.Linq
 			if (list != null)
 				return index < list.Count ? list [index] : default (TSource);
 
-			int counter = 0;
-			foreach (TSource element in source) {
-				if (counter == index)
-					return element;
-				counter++;
-			}
-
-			return default (TSource);
+			return source.ElementAt (index, Fallback.Default);
 		}
 
 		#endregion
@@ -671,9 +560,9 @@ namespace System.Linq
 
 		static IEnumerable<TSource> CreateExceptIterator<TSource> (IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer)
 		{
-			var items = new HashSet<TSource> (Distinct (second));
-			foreach (TSource element in first) {
-				if (! items.Contains (element, comparer))
+			var items = new HashSet<TSource> (second, comparer);
+			foreach (var element in first) {
+				if (!items.Contains (element, comparer))
 					yield return element;
 			}
 		}
@@ -682,27 +571,43 @@ namespace System.Linq
 
 		#region First
 
+		static TSource First<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate, Fallback fallback)
+		{
+			foreach (var element in source)
+				if (predicate (element))
+					return element;
+
+			if (fallback == Fallback.Throw)
+				throw new InvalidOperationException ();
+
+			return default (TSource);
+		}
+
 		public static TSource First<TSource> (this IEnumerable<TSource> source)
 		{
 			Check.Source (source);
 
-			foreach (TSource element in source)
-				return element;
+			var list = source as IList<TSource>;
+			if (list != null) {
+				if (list.Count != 0)
+					return list [0];
+
+				throw new InvalidOperationException ();
+			} else {
+				using (var enumerator = source.GetEnumerator ()) {
+					if (enumerator.MoveNext ())
+						return enumerator.Current;
+				}
+			}
 
 			throw new InvalidOperationException ();
 		}
 
-
 		public static TSource First<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate)
 		{
 			Check.SourceAndPredicate (source, predicate);
 
-			foreach (TSource element in source) {
-				if (predicate (element))
-					return element;
-			}
-
-			throw new InvalidOperationException ();
+			return source.First (predicate, Fallback.Throw);
 		}
 
 		#endregion
@@ -713,23 +618,14 @@ namespace System.Linq
 		{
 			Check.Source (source);
 
-			foreach (TSource element in source)
-				return element;
-
-			return default (TSource);
+			return source.First (PredicateOf<TSource>.Always, Fallback.Default);
 		}
 
-
 		public static TSource FirstOrDefault<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate)
 		{
 			Check.SourceAndPredicate (source, predicate);
 
-			foreach (TSource element in source) {
-				if (predicate (element))
-					return element;
-			}
-
-			return default (TSource);
+			return source.First (predicate, Fallback.Default);
 		}
 
 		#endregion
@@ -747,7 +643,6 @@ namespace System.Linq
 			return null;
 		}
 
-
 		public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey> (this IEnumerable<TSource> source,
 			Func<TSource, TKey> keySelector)
 		{
@@ -759,6 +654,12 @@ namespace System.Linq
 		{
 			Check.SourceAndKeySelector (source, keySelector);
 
+			return CreateGroupByIterator (source, keySelector, comparer);
+		}
+
+		static IEnumerable<IGrouping<TKey, TSource>> CreateGroupByIterator<TSource, TKey> (this IEnumerable<TSource> source,
+			Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
+		{
 			Dictionary<TKey, List<TSource>> groups = new Dictionary<TKey, List<TSource>> ();
 			List<TSource> nullList = new List<TSource> ();
 			int counter = 0;
@@ -796,7 +697,6 @@ namespace System.Linq
 			}
 		}
 
-
 		public static IEnumerable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement> (this IEnumerable<TSource> source,
 			Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector)
 		{
@@ -853,13 +753,16 @@ namespace System.Linq
 			return GroupBy (source, keySelector, elementSelector, resultSelector, null);
 		}
 
-		[MonoTODO]
 		public static IEnumerable<TResult> GroupBy<TSource, TKey, TElement, TResult> (this IEnumerable<TSource> source,
 			Func<TSource, TKey> keySelector, Func<TSource, TElement> elementSelector,
 			Func<TKey, IEnumerable<TElement>, TResult> resultSelector,
 			IEqualityComparer<TKey> comparer)
 		{
-			throw new NotImplementedException ();
+			IEnumerable<IGrouping<TKey, TElement>> groups = GroupBy<TSource, TKey, TElement> (
+				source, keySelector, elementSelector, comparer);
+
+			foreach (IGrouping<TKey, TElement> group in groups)
+				yield return resultSelector (group.Key, group);
 		}
 
 		public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult> (this IEnumerable<TSource> source,
@@ -869,13 +772,15 @@ namespace System.Linq
 			return GroupBy (source, keySelector, resultSelector, null);
 		}
 
-		[MonoTODO]
 		public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult> (this IEnumerable<TSource> source,
 			Func<TSource, TKey> keySelector,
 			Func<TKey, IEnumerable<TSource>, TResult> resultSelector,
 			IEqualityComparer<TKey> comparer)
 		{
-			throw new NotImplementedException ();
+			IEnumerable<IGrouping<TKey,TSource>> groups = GroupBy<TSource, TKey> (source, keySelector, comparer);
+
+			foreach (IGrouping<TKey, TSource> group in groups)
+				yield return resultSelector (group.Key, group);
 		}
 
 		#endregion
@@ -899,6 +804,14 @@ namespace System.Linq
 			if (comparer == null)
 				comparer = EqualityComparer<TKey>.Default;
 
+			return CreateGroupJoinIterator (outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer);
+		}
+
+		static IEnumerable<TResult> CreateGroupJoinIterator<TOuter, TInner, TKey, TResult> (this IEnumerable<TOuter> outer,
+			IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector,
+			Func<TInner, TKey> innerKeySelector, Func<TOuter, IEnumerable<TInner>, TResult> resultSelector,
+			IEqualityComparer<TKey> comparer)
+		{
 			ILookup<TKey, TInner> innerKeys = ToLookup<TInner, TKey> (inner, innerKeySelector, comparer);
 			/*Dictionary<K, List<U>> innerKeys = new Dictionary<K, List<U>> ();
 			foreach (U element in inner)
@@ -941,7 +854,7 @@ namespace System.Linq
 		{
 			var items = new HashSet<TSource> (second, comparer);
 			foreach (TSource element in first) {
-				if (items.Contains (element))
+				if (items.Remove (element))
 					yield return element;
 			}
 		}
@@ -959,6 +872,13 @@ namespace System.Linq
 			if (comparer == null)
 				comparer = EqualityComparer<TKey>.Default;
 
+			return CreateJoinIterator (outer, inner, outerKeySelector, innerKeySelector, resultSelector, comparer);
+		}
+
+		static IEnumerable<TResult> CreateJoinIterator<TOuter, TInner, TKey, TResult> (this IEnumerable<TOuter> outer,
+			IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector,
+			Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector, IEqualityComparer<TKey> comparer)
+		{
 			ILookup<TKey, TInner> innerKeys = ToLookup<TInner, TKey> (inner, innerKeySelector, comparer);
 			/*Dictionary<K, List<U>> innerKeys = new Dictionary<K, List<U>> ();
 			foreach (U element in inner)
@@ -982,48 +902,55 @@ namespace System.Linq
 			IEnumerable<TInner> inner, Func<TOuter, TKey> outerKeySelector,
 			Func<TInner, TKey> innerKeySelector, Func<TOuter, TInner, TResult> resultSelector)
 		{
-			return Join<TOuter, TInner, TKey, TResult> (outer, inner, outerKeySelector, innerKeySelector, resultSelector, null);
+			return outer.Join (inner, outerKeySelector, innerKeySelector, resultSelector, null);
 		}
 
-		# endregion
+		#endregion
 
 		#region Last
 
-		public static TSource Last<TSource> (this IEnumerable<TSource> source)
+		static TSource Last<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate, Fallback fallback)
 		{
-			Check.Source (source);
+			var empty = true;
+			var item = default (TSource);
 
-			bool noElements = true;
-			TSource lastElement = default (TSource);
-			foreach (TSource element in source) {
-				if (noElements) noElements = false;
-				lastElement = element;
+			foreach (var element in source) {
+				if (!predicate (element))
+					continue;
+
+				item = element;
+				empty = false;
 			}
 
-			if (!noElements)
-				return lastElement;
-			else
+			if (!empty)
+				return item;
+
+			if (fallback == Fallback.Throw)
+				throw new InvalidOperationException ();
+
+			return item;
+		}
+
+		public static TSource Last<TSource> (this IEnumerable<TSource> source)
+		{
+			Check.Source (source);
+
+			var collection = source as ICollection<TSource>;
+			if (collection != null && collection.Count == 0)
 				throw new InvalidOperationException ();
+
+			var list = source as IList<TSource>;
+			if (list != null)
+				return list [list.Count - 1];
+
+			return source.Last (PredicateOf<TSource>.Always, Fallback.Throw);
 		}
 
-		public static TSource Last<TSource> (this IEnumerable<TSource> source,
-				Func<TSource, bool> predicate)
+		public static TSource Last<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate)
 		{
 			Check.SourceAndPredicate (source, predicate);
 
-			bool noElements = true;
-			TSource lastElement = default (TSource);
-			foreach (TSource element in source) {
-				if (predicate (element)) {
-					if (noElements) noElements = false;
-					lastElement = element;
-				}
-			}
-
-			if (!noElements)
-				return lastElement;
-			else
-				throw new InvalidOperationException ();
+			return source.Last (predicate, Fallback.Throw);
 		}
 
 		#endregion
@@ -1038,34 +965,30 @@ namespace System.Linq
 			if (list != null)
 				return list.Count > 0 ? list [list.Count - 1] : default (TSource);
 
-			TSource lastElement = default (TSource);
-			foreach (TSource element in source)
-				lastElement = element;
-
-			return lastElement;
+			return source.Last (PredicateOf<TSource>.Always, Fallback.Default);
 		}
 
-		public static TSource LastOrDefault<TSource> (this IEnumerable<TSource> source,
-			Func<TSource, bool> predicate)
+		public static TSource LastOrDefault<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate)
 		{
 			Check.SourceAndPredicate (source, predicate);
 
-			TSource lastElement = default (TSource);
-			foreach (TSource element in source) {
-				if (predicate (element))
-					lastElement = element;
-			}
-
-			return lastElement;
+			return source.Last (predicate, Fallback.Default);
 		}
 
 		#endregion
 
 		#region LongCount
+
 		public static long LongCount<TSource> (this IEnumerable<TSource> source)
 		{
 			Check.Source (source);
 
+#if !NET_2_1
+			var array = source as TSource [];
+			if (array != null)
+				return array.LongLength;
+#endif
+
 			long counter = 0;
 			using (var enumerator = source.GetEnumerator ())
 				while (enumerator.MoveNext ())
@@ -1129,51 +1052,78 @@ namespace System.Linq
 		{
 			Check.Source (source);
 
-			return IterateNullable (source, int.MinValue, (a, b) => a > b);
+			return IterateNullable (source, (a, b) => Math.Max (a, b));
 		}
 
 		public static long? Max (this IEnumerable<long?> source)
 		{
 			Check.Source (source);
 
-			return IterateNullable (source, long.MinValue, (a, b) => a > b);
+			return IterateNullable (source, (a, b) => Math.Max (a, b));
 		}
 
 		public static double? Max (this IEnumerable<double?> source)
 		{
 			Check.Source (source);
 
-			return IterateNullable (source, double.MinValue, (a, b) => a > b);
+			return IterateNullable (source, (a, b) => Math.Max (a, b));
 		}
 
 		public static float? Max (this IEnumerable<float?> source)
 		{
 			Check.Source (source);
 
-			return IterateNullable (source, float.MinValue, (a, b) => a > b);
+			return IterateNullable (source, (a, b) => Math.Max (a, b));
 		}
 
 		public static decimal? Max (this IEnumerable<decimal?> source)
 		{
 			Check.Source (source);
 
-			return IterateNullable (source, decimal.MinValue, (a, b) => a > b);
+			return IterateNullable (source, (a, b) => Math.Max (a, b));
 		}
 
-		static T? IterateNullable<T> (IEnumerable<T?> source, T initValue, Func<T?, T?, bool> selector) where T : struct
+		static T? IterateNullable<T> (IEnumerable<T?> source, Func<T, T, T> selector) where T : struct
 		{
-			int counter = 0;
-			T? value = initValue;
+			bool empty = true;
+			T? value = null;
 			foreach (var element in source) {
 				if (!element.HasValue)
 					continue;
 
-				if (selector (element.Value, value))
-					value = element;
-				++counter;
+				if (!value.HasValue)
+					value = element.Value;
+				else
+					value = selector (element.Value, value.Value);
+
+				empty = false;
 			}
 
-			if (counter == 0)
+			if (empty)
+				return null;
+
+			return value;
+		}
+
+		static TRet? IterateNullable<TSource, TRet> (
+			IEnumerable<TSource> source,
+			Func<TSource, TRet?> source_selector,
+			Func<TRet?, TRet?, bool> selector) where TRet : struct
+		{
+			bool empty = true;
+			TRet? value = null;
+			foreach (var element in source) {
+				TRet? item = source_selector (element);
+
+				if (!value.HasValue)
+					value = item;
+				else if (selector (item, value))
+					value = item;
+
+				empty = false;
+			}
+
+			if (empty)
 				return null;
 
 			return value;
@@ -1248,79 +1198,51 @@ namespace System.Linq
 
 		static U Iterate<T, U> (IEnumerable<T> source, U initValue, Func<T, U, U> selector)
 		{
-			int counter = 0;
+			bool empty = true;
 			foreach (var element in source) {
 				initValue = selector (element, initValue);
-				++counter;
+				empty = false;
 			}
 
-			if (counter == 0)
+			if (empty)
 				throw new InvalidOperationException ();
 
 			return initValue;
 		}
 
-		static U? IterateNullable<T, U> (IEnumerable<T> source, U initialValue, Func<T, U?, U?> selector) where U : struct
-		{
-			int counter = 0;
-			U? value = initialValue;
-			foreach (var element in source) {
-				value = selector (element, value);
-				if (!value.HasValue)
-					continue;
-
-				++counter;
-			}
-
-			if (counter == 0)
-				return null;
-
-			return value;
-		}
-
 		public static int? Max<TSource> (this IEnumerable<TSource> source, Func<TSource, int?> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			return IterateNullable (source, int.MinValue, (a, b) => {
-				var v = selector (a); return v > b ? v : b;
-			});
+			return IterateNullable (source, selector, (a, b) => a > b);
 		}
 
 		public static long? Max<TSource> (this IEnumerable<TSource> source, Func<TSource, long?> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			return IterateNullable (source, long.MinValue, (a, b) => {
-				var v = selector (a); return v > b ? v : b;
-			});
+			return IterateNullable (source, selector, (a, b) => a > b);
 		}
 
 		public static double? Max<TSource> (this IEnumerable<TSource> source, Func<TSource, double?> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			return IterateNullable (source, double.MinValue, (a, b) => {
-				var v = selector (a); return v > b ? v : b;
-			});
+			return IterateNullable (source, selector, (a, b) => a > b);
 		}
 
 		public static float? Max<TSource> (this IEnumerable<TSource> source, Func<TSource, float?> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			return IterateNullable (source, float.MinValue, (a, b) => {
-				var v = selector (a); return v > b ? v : b;
-			});
+			return IterateNullable (source, selector, (a, b) => a > b);
 		}
 
 		public static decimal? Max<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal?> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			return IterateNullable (source, decimal.MinValue, (a, b) => {
-				var v = selector (a); return v > b ? v : b;
-			});
+			return IterateNullable (source, selector, (a, b) => a > b);
 		}
 
 		public static TResult Max<TSource, TResult> (this IEnumerable<TSource> source, Func<TSource, TResult> selector)
@@ -1399,35 +1321,35 @@ namespace System.Linq
 		{
 			Check.Source (source);
 
-			return IterateNullable (source, int.MaxValue, (a, b) => a < b);
+			return IterateNullable (source, (a, b) => Math.Min (a, b));
 		}
 
 		public static long? Min (this IEnumerable<long?> source)
 		{
 			Check.Source (source);
 
-			return IterateNullable (source, long.MaxValue, (a, b) => a < b);
+			return IterateNullable (source, (a, b) => Math.Min (a, b));
 		}
 
 		public static double? Min (this IEnumerable<double?> source)
 		{
 			Check.Source (source);
 
-			return IterateNullable (source, double.MaxValue, (a, b) => a < b);
+			return IterateNullable (source, (a, b) => Math.Min (a, b));
 		}
 
 		public static float? Min (this IEnumerable<float?> source)
 		{
 			Check.Source (source);
 
-			return IterateNullable (source, float.MaxValue, (a, b) => a < b);
+			return IterateNullable (source, (a, b) => Math.Min (a, b));
 		}
 
 		public static decimal? Min (this IEnumerable<decimal?> source)
 		{
 			Check.Source (source);
 
-			return IterateNullable (source, decimal.MaxValue, (a, b) => a < b);
+			return IterateNullable (source, (a, b) => Math.Min (a, b));
 		}
 
 		public static TSource Min<TSource> (this IEnumerable<TSource> source)
@@ -1501,45 +1423,35 @@ namespace System.Linq
 		{
 			Check.SourceAndSelector (source, selector);
 
-			return IterateNullable (source, int.MaxValue, (a, b) => {
-				var v = selector (a); return v < b ? v : b;
-			});
+			return IterateNullable (source, selector, (a, b) => a < b);
 		}
 
 		public static long? Min<TSource> (this IEnumerable<TSource> source, Func<TSource, long?> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			return IterateNullable (source, long.MaxValue, (a, b) => {
-				var v = selector (a); return v < b ? v : b;
-			});
+			return IterateNullable (source, selector, (a, b) => a < b);
 		}
 
 		public static float? Min<TSource> (this IEnumerable<TSource> source, Func<TSource, float?> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			return IterateNullable (source, float.MaxValue, (a, b) => {
-				var v = selector (a); return v < b ? v : b;
-			});
+			return IterateNullable (source, selector, (a, b) => a < b);
 		}
 
 		public static double? Min<TSource> (this IEnumerable<TSource> source, Func<TSource, double?> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			return IterateNullable (source, double.MaxValue, (a, b) => {
-				var v = selector (a); return v < b ? v : b;
-			});
+			return IterateNullable (source, selector, (a, b) => a < b);
 		}
 
 		public static decimal? Min<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal?> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			return IterateNullable (source, decimal.MaxValue, (a, b) => {
-				var v = selector (a); return v < b ? v : b;
-			});
+			return IterateNullable (source, selector, (a, b) => a < b);
 		}
 
 		public static TResult Min<TSource, TResult> (this IEnumerable<TSource> source, Func<TSource, TResult> selector)
@@ -1603,15 +1515,13 @@ namespace System.Linq
 			return OrderBy<TSource, TKey> (source, keySelector, null);
 		}
 
-
 		public static IOrderedEnumerable<TSource> OrderBy<TSource, TKey> (this IEnumerable<TSource> source,
 				Func<TSource, TKey> keySelector,
 				IComparer<TKey> comparer)
 		{
 			Check.SourceAndKeySelector (source, keySelector);
 
-			return new OrderedSequence<TSource, TKey> (
-					source, keySelector, comparer, false);
+			return new OrderedSequence<TSource, TKey> (source, keySelector, comparer, SortDirection.Ascending);
 		}
 
 		#endregion
@@ -1624,14 +1534,12 @@ namespace System.Linq
 			return OrderByDescending<TSource, TKey> (source, keySelector, null);
 		}
 
-
 		public static IOrderedEnumerable<TSource> OrderByDescending<TSource, TKey> (this IEnumerable<TSource> source,
 				Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
 		{
 			Check.SourceAndKeySelector (source, keySelector);
 
-			return new OrderedSequence<TSource, TKey> (
-					source, keySelector, comparer, true);
+			return new OrderedSequence<TSource, TKey> (source, keySelector, comparer, SortDirection.Descending);
 		}
 
 		#endregion
@@ -1677,21 +1585,23 @@ namespace System.Linq
 
 		#endregion
 
-
 		#region Reverse
 
 		public static IEnumerable<TSource> Reverse<TSource> (this IEnumerable<TSource> source)
 		{
 			Check.Source (source);
 
-			return CreateReverseIterator (source);
+			var list = source as IList<TSource>;
+			if (list == null)
+				list = new List<TSource> (source);
+
+			return CreateReverseIterator (list);
 		}
 
-		static IEnumerable<TSource> CreateReverseIterator<TSource> (IEnumerable<TSource> source)
+		static IEnumerable<TSource> CreateReverseIterator<TSource> (IList<TSource> source)
 		{
-			var list = new List<TSource> (source);
-			list.Reverse ();
-			return list;
+			for (int i = source.Count; i > 0; --i)
+				yield return source [i - 1];
 		}
 
 		#endregion
@@ -1707,7 +1617,7 @@ namespace System.Linq
 
 		static IEnumerable<TResult> CreateSelectIterator<TSource, TResult> (IEnumerable<TSource> source, Func<TSource, TResult> selector)
 		{
-			foreach (TSource element in source)
+			foreach (var element in source)
 				yield return selector (element);
 		}
 
@@ -1799,44 +1709,40 @@ namespace System.Linq
 
 		#region Single
 
-		public static TSource Single<TSource> (this IEnumerable<TSource> source)
+		static TSource Single<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate, Fallback fallback)
 		{
-			Check.Source (source);
+			var found = false;
+			var item = default (TSource);
 
-			bool otherElement = false;
-			TSource singleElement = default (TSource);
-			foreach (TSource element in source) {
-				if (otherElement) throw new InvalidOperationException ();
-				if (!otherElement) otherElement = true;
-				singleElement = element;
+			foreach (var element in source) {
+				if (!predicate (element))
+					continue;
+
+				if (found)
+					throw new InvalidOperationException ();
+
+				found = true;
+				item = element;
 			}
 
-			if (otherElement)
-				return singleElement;
-			else
+			if (!found && fallback == Fallback.Throw)
 				throw new InvalidOperationException ();
+
+			return item;
 		}
 
+		public static TSource Single<TSource> (this IEnumerable<TSource> source)
+		{
+			Check.Source (source);
 
-		public static TSource Single<TSource> (this IEnumerable<TSource> source,
-				Func<TSource, bool> predicate)
+			return source.Single (PredicateOf<TSource>.Always, Fallback.Throw);
+		}
+
+		public static TSource Single<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate)
 		{
 			Check.SourceAndPredicate (source, predicate);
 
-			bool otherElement = false;
-			TSource singleElement = default (TSource);
-			foreach (TSource element in source) {
-				if (predicate (element)) {
-					if (otherElement) throw new InvalidOperationException ();
-					if (!otherElement) otherElement = true;
-					singleElement = element;
-				}
-			}
-
-			if (otherElement)
-				return singleElement;
-			else
-				throw new InvalidOperationException ();
+			return source.Single (predicate, Fallback.Throw);
 		}
 
 		#endregion
@@ -1847,34 +1753,14 @@ namespace System.Linq
 		{
 			Check.Source (source);
 
-			bool otherElement = false;
-			TSource singleElement = default (TSource);
-			foreach (TSource element in source) {
-				if (otherElement) throw new InvalidOperationException ();
-				if (!otherElement) otherElement = true;
-				singleElement = element;
-			}
-
-			return singleElement;
+			return source.Single (PredicateOf<TSource>.Always, Fallback.Default);
 		}
 
-
-		public static TSource SingleOrDefault<TSource> (this IEnumerable<TSource> source,
-				Func<TSource, bool> predicate)
+		public static TSource SingleOrDefault<TSource> (this IEnumerable<TSource> source, Func<TSource, bool> predicate)
 		{
 			Check.SourceAndPredicate (source, predicate);
 
-			bool otherElement = false;
-			TSource singleElement = default (TSource);
-			foreach (TSource element in source) {
-				if (predicate (element)) {
-					if (otherElement) throw new InvalidOperationException ();
-					if (!otherElement) otherElement = true;
-					singleElement = element;
-				}
-			}
-
-			return singleElement;
+			return source.Single (predicate, Fallback.Default);
 		}
 
 		#endregion
@@ -1957,30 +1843,30 @@ namespace System.Linq
 		{
 			Check.Source (source);
 
-			return Sum<int, int> (source, (a, b) => a + b);
+			return Sum<int, int> (source, (a, b) => checked (a + b));
 		}
 
 		public static int? Sum (this IEnumerable<int?> source)
 		{
 			Check.Source (source);
 
-			return SumNullable<int?, int?> (source, (a, b) => a.HasValue ? a + b : a);
+			return source.SumNullable<int?, int?> (0, (total, element) => element.HasValue ? checked (total + element) : total);
 		}
 
 		public static int Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, int> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			return Sum<TSource, int> (source, (a, b) => a + selector (b));
+			return Sum<TSource, int> (source, (a, b) => checked (a + selector (b)));
 		}
 
 		public static int? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, int?> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			return SumNullable<TSource, int?> (source, (a, b) => {
+			return source.SumNullable<TSource, int?> (0, (a, b) => {
 				var value = selector (b);
-				return value.HasValue ? a + value.Value : a;
+				return value.HasValue ? checked (a + value.Value) : a;
 			});
 		}
 
@@ -1988,30 +1874,30 @@ namespace System.Linq
 		{
 			Check.Source (source);
 
-			return Sum<long, long> (source, (a, b) => a + b);
+			return Sum<long, long> (source, (a, b) => checked (a + b));
 		}
 
 		public static long? Sum (this IEnumerable<long?> source)
 		{
 			Check.Source (source);
 
-			return SumNullable<long?, long?> (source, (a, b) => a.HasValue ? a + b : a);
+			return source.SumNullable<long?, long?> (0, (total, element) => element.HasValue ? checked (total + element) : total);
 		}
 
 		public static long Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, long> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			return Sum<TSource, long> (source, (a, b) => a + selector (b));
+			return Sum<TSource, long> (source, (a, b) => checked (a + selector (b)));
 		}
 
 		public static long? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, long?> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			return SumNullable<TSource, long?> (source, (a, b) => {
+			return source.SumNullable<TSource, long?> (0, (a, b) => {
 				var value = selector (b);
-				return value.HasValue ? a + value.Value : a;
+				return value.HasValue ? checked (a + value.Value) : a;
 			});
 		}
 
@@ -2019,30 +1905,30 @@ namespace System.Linq
 		{
 			Check.Source (source);
 
-			return Sum<double, double> (source, (a, b) => a + b);
+			return Sum<double, double> (source, (a, b) => checked (a + b));
 		}
 
 		public static double? Sum (this IEnumerable<double?> source)
 		{
 			Check.Source (source);
 
-			return SumNullable<double?, double?> (source, (a, b) => a.HasValue ? a + b : a);
+			return source.SumNullable<double?, double?> (0, (total, element) => element.HasValue ? checked (total + element) : total);
 		}
 
 		public static double Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, double> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			return Sum<TSource, double> (source, (a, b) => a + selector (b));
+			return Sum<TSource, double> (source, (a, b) => checked (a + selector (b)));
 		}
 
 		public static double? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, double?> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			return SumNullable<TSource, double?> (source, (a, b) => {
+			return source.SumNullable<TSource, double?> (0, (a, b) => {
 				var value = selector (b);
-				return value.HasValue ? a + value.Value : a;
+				return value.HasValue ? checked (a + value.Value) : a;
 			});
 		}
 
@@ -2050,30 +1936,30 @@ namespace System.Linq
 		{
 			Check.Source (source);
 
-			return Sum<float, float> (source, (a, b) => a + b);
+			return Sum<float, float> (source, (a, b) => checked (a + b));
 		}
 
 		public static float? Sum (this IEnumerable<float?> source)
 		{
 			Check.Source (source);
 
-			return SumNullable<float?, float?> (source, (a, b) => a.HasValue ? a + b : a);
+			return source.SumNullable<float?, float?> (0, (total, element) => element.HasValue ? checked (total + element) : total);
 		}
 
 		public static float Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, float> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			return Sum<TSource, float> (source, (a, b) => a + selector (b));
+			return Sum<TSource, float> (source, (a, b) => checked (a + selector (b)));
 		}
 
 		public static float? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, float?> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			return SumNullable<TSource, float?> (source, (a, b) => {
+			return source.SumNullable<TSource, float?> (0, (a, b) => {
 				var value = selector (b);
-				return value.HasValue ? a + value.Value : a;
+				return value.HasValue ? checked (a + value.Value) : a;
 			});
 		}
 
@@ -2081,51 +1967,48 @@ namespace System.Linq
 		{
 			Check.Source (source);
 
-			return Sum<decimal, decimal> (source, (a, b) => a + b);
+			return Sum<decimal, decimal> (source, (a, b) => checked (a + b));
 		}
 
 		public static decimal? Sum (this IEnumerable<decimal?> source)
 		{
 			Check.Source (source);
 
-			return SumNullable<decimal?, decimal?> (source, (a, b) => a.HasValue ? a + b : a);
+			return source.SumNullable<decimal?, decimal?> (0, (total, element) => element.HasValue ? checked (total + element) : total);
 		}
 
 		public static decimal Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			return Sum<TSource, decimal> (source, (a, b) => a + selector (b));
+			return Sum<TSource, decimal> (source, (a, b) => checked (a + selector (b)));
 		}
 
 		public static decimal? Sum<TSource> (this IEnumerable<TSource> source, Func<TSource, decimal?> selector)
 		{
 			Check.SourceAndSelector (source, selector);
 
-			return SumNullable<TSource, decimal?> (source, (a, b) => {
+			return source.SumNullable<TSource, decimal?> (0, (a, b) => {
 				var value = selector (b);
-				return value.HasValue ? a + value.Value : a;
+				return value.HasValue ? checked (a + value.Value) : a;
 			});
 		}
 
 		static TR Sum<TA, TR> (this IEnumerable<TA> source, Func<TR, TA, TR> selector)
 		{
 			TR total = default (TR);
-			int counter = 0;
+			long counter = 0;
 			foreach (var element in source) {
 				total = selector (total, element);
 				++counter;
 			}
 
-			if (counter == 0)
-				throw new InvalidOperationException ();
-
 			return total;
 		}
 
-		static TR SumNullable<TA, TR> (this IEnumerable<TA> source, Func<TR, TA, TR> selector)
+		static TR SumNullable<TA, TR> (this IEnumerable<TA> source, TR zero, Func<TR, TA, TR> selector)
 		{
-			TR total = default (TR);
+			TR total = zero;
 			foreach (var element in source) {
 				total = selector (total, element);
 			}
@@ -2151,10 +2034,10 @@ namespace System.Linq
 
 			int counter = 0;
 			foreach (TSource element in source) {
-				if (counter++ == count)
-					yield break;
-
 				yield return element;
+
+				if (++counter == count)
+					yield break;
 			}
 		}
 
@@ -2171,7 +2054,7 @@ namespace System.Linq
 
 		static IEnumerable<TSource> CreateTakeWhileIterator<TSource> (IEnumerable<TSource> source, Func<TSource, bool> predicate)
 		{
-			foreach (TSource element in source) {
+			foreach (var element in source) {
 				if (!predicate (element))
 					yield break;
 
@@ -2207,7 +2090,6 @@ namespace System.Linq
 			return ThenBy<TSource, TKey> (source, keySelector, null);
 		}
 
-
 		public static IOrderedEnumerable<TSource> ThenBy<TSource, TKey> (this IOrderedEnumerable<TSource> source,
 			Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
 		{
@@ -2226,7 +2108,6 @@ namespace System.Linq
 			return ThenByDescending<TSource, TKey> (source, keySelector, null);
 		}
 
-
 		public static IOrderedEnumerable<TSource> ThenByDescending<TSource, TKey> (this IOrderedEnumerable<TSource> source,
 			Func<TSource, TKey> keySelector, IComparer<TKey> comparer)
 		{
@@ -2238,12 +2119,19 @@ namespace System.Linq
 		#endregion
 
 		#region ToArray
+
 		public static TSource [] ToArray<TSource> (this IEnumerable<TSource> source)
 		{
 			Check.Source (source);
 
-			List<TSource> list = new List<TSource> (source);
-			return list.ToArray ();
+			var collection = source as ICollection<TSource>;
+			if (collection != null) {
+				var array = new TSource [collection.Count];
+				collection.CopyTo (array, 0);
+				return array;
+			}
+
+			return new List<TSource> (source).ToArray ();
 		}
 
 		#endregion
@@ -2279,16 +2167,7 @@ namespace System.Linq
 		public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey> (this IEnumerable<TSource> source,
 				Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
 		{
-			Check.SourceAndKeySelector (source, keySelector);
-
-			if (comparer == null)
-				comparer = EqualityComparer<TKey>.Default;
-
-			var dict = new Dictionary<TKey, TSource> (comparer);
-			foreach (var e in source)
-				dict.Add (keySelector (e), e);
-
-			return dict;
+			return ToDictionary<TSource, TKey, TSource> (source, keySelector, Function<TSource>.Identity, comparer);
 		}
 
 		#endregion
@@ -2306,24 +2185,13 @@ namespace System.Linq
 
 		public static ILookup<TKey, TSource> ToLookup<TSource, TKey> (this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
 		{
-			return ToLookup<TSource, TKey> (source, keySelector, null);
+			return ToLookup<TSource, TKey, TSource> (source, keySelector, Function<TSource>.Identity, null);
 		}
 
 		public static ILookup<TKey, TSource> ToLookup<TSource, TKey> (this IEnumerable<TSource> source,
 			Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
 		{
-			Check.SourceAndKeySelector (source, keySelector);
-
-			var dictionary = new Dictionary<TKey, List<TSource>> (comparer ?? EqualityComparer<TKey>.Default);
-			foreach (TSource element in source) {
-				TKey key = keySelector (element);
-				if (key == null)
-					throw new ArgumentNullException ();
-				if (!dictionary.ContainsKey (key))
-					dictionary.Add (key, new List<TSource> ());
-				dictionary [key].Add (element);
-			}
-			return new Lookup<TKey, TSource> (dictionary);
+			return ToLookup<TSource, TKey, TSource> (source, keySelector, element => element, comparer);
 		}
 
 		public static ILookup<TKey, TElement> ToLookup<TSource, TKey, TElement> (this IEnumerable<TSource> source,
@@ -2337,15 +2205,21 @@ namespace System.Linq
 		{
 			Check.SourceAndKeyElementSelectors (source, keySelector, elementSelector);
 
-			Dictionary<TKey, List<TElement>> dictionary = new Dictionary<TKey, List<TElement>> (comparer ?? EqualityComparer<TKey>.Default);
-			foreach (TSource element in source) {
-				TKey key = keySelector (element);
+			var dictionary = new Dictionary<TKey, List<TElement>> (comparer ?? EqualityComparer<TKey>.Default);
+			foreach (var element in source) {
+				var key = keySelector (element);
 				if (key == null)
-					throw new ArgumentNullException ();
-				if (!dictionary.ContainsKey (key))
-					dictionary.Add (key, new List<TElement> ());
-				dictionary [key].Add (elementSelector (element));
+					throw new ArgumentNullException ("key");
+
+				List<TElement> list;
+				if (!dictionary.TryGetValue (key, out list)) {
+					list = new List<TElement> ();
+					dictionary.Add (key, list);
+				}
+
+				list.Add (elementSelector (element));
 			}
+
 			return new Lookup<TKey, TElement> (dictionary);
 		}
 
@@ -2365,18 +2239,19 @@ namespace System.Linq
 			if (comparer == null)
 				comparer = EqualityComparer<TSource>.Default;
 
-			var first_enumerator = first.GetEnumerator ();
-			var second_enumerator = second.GetEnumerator ();
+			using (IEnumerator<TSource> first_enumerator = first.GetEnumerator (),
+				second_enumerator = second.GetEnumerator ()) {
 
-			while (first_enumerator.MoveNext ()) {
-				if (!second_enumerator.MoveNext ())
-					return false;
+				while (first_enumerator.MoveNext ()) {
+					if (!second_enumerator.MoveNext ())
+						return false;
 
-				if (!comparer.Equals (first_enumerator.Current, second_enumerator.Current))
-					return false;
-			}
+					if (!comparer.Equals (first_enumerator.Current, second_enumerator.Current))
+						return false;
+				}
 
-			return !second_enumerator.MoveNext ();
+				return !second_enumerator.MoveNext ();
+			}
 		}
 
 		#endregion