Enumerable.IsFirst/IsLast

Author: andrewvk

Main/src/Collections/CollectionExtensions.cs

@@ -1,5 +1,4 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 
 using JetBrains.Annotations;
 

Main/src/Collections/Enumerable/EnumerableExtensions.cs

@@ -438,5 +438,131 @@ private static IEnumerable<string> ToStringsCore<T>(IEnumerable<T> source)
 			foreach (var obj in source)
 				yield return obj?.ToString() ?? "";
 		}
+
+		/// <summary>
+		/// Checks, if <paramref name="item"/> is first element of <paramref name="source"/>.
+		/// </summary>
+		/// <typeparam name="TSource">The type of the elements of source.</typeparam>
+		/// <param name="source">An <see cref="IEnumerable{T}"/> to check.</param>
+		/// <param name="item">Source item to compare with first element.</param>
+		/// <returns>
+		/// <c>true</c>, if <paramref name="source"/> has at least one element and first element is equals to
+		/// <paramref name="item"/>, otherwise <c>false</c>.
+		/// </returns>
+		public static bool IsFirst<TSource>([NotNull] this IEnumerable<TSource> source, TSource item)
+		{
+			Code.NotNull(source, nameof(source));
+
+			// Fast path
+			// ReSharper disable once CollectionNeverUpdated.Local
+			if (source is IList<TSource> list)
+				return Equals(item, list[0]);
+
+			foreach (var current in source)
+				return Equals(item, current);
+			return false;
+		}
+
+		/// <summary>
+		/// Checks, if <paramref name="item"/> is first element of <paramref name="source"/>.
+		/// </summary>
+		/// <typeparam name="TSource">The type of the elements of source.</typeparam>
+		/// <param name="source">An <see cref="IEnumerable{T}"/> to check.</param>
+		/// <param name="item">Source item to compare with first element.</param>
+		/// <param name="comparer">The comparer.</param>
+		/// <returns>
+		/// <c>true</c>, if <paramref name="source"/> has at least one element and first element is equals to
+		/// <paramref name="item"/>, otherwise <c>false</c>.
+		/// </returns>
+		public static bool IsFirst<TSource>(
+			[NotNull] this IEnumerable<TSource> source,
+			TSource item,
+			[CanBeNull] IEqualityComparer<TSource> comparer)
+		{
+			Code.NotNull(source, nameof(source));
+
+			comparer = comparer ?? EqualityComparer<TSource>.Default;
+
+			// Fast path
+			// ReSharper disable once CollectionNeverUpdated.Local
+			if (source is IList<TSource> list)
+				return comparer.Equals(item, list[0]);
+
+			foreach (var current in source)
+				return comparer.Equals(item, current);
+			return false;
+		}
+
+		/// <summary>
+		/// Checks, if <paramref name="item"/> is last element of <paramref name="source"/>.
+		/// </summary>
+		/// <typeparam name="TSource">The type of the elements of source.</typeparam>
+		/// <param name="source">An <see cref="IEnumerable{T}"/> to check.</param>
+		/// <param name="item">Source item to compare with last element.</param>
+		/// <returns>
+		/// <c>true</c>, if <paramref name="source"/> has at least one element and last element is equals to
+		/// <paramref name="item"/>, otherwise <c>false</c>.
+		/// </returns>
+		public static bool IsLast<TSource>([NotNull] this IEnumerable<TSource> source, TSource item)
+		{
+			Code.NotNull(source, nameof(source));
+
+			// Fast path
+			// ReSharper disable once CollectionNeverUpdated.Local
+			if (source is IList<TSource> list)
+				return Equals(item, list[list.Count - 1]);
+
+			using (var en = source.GetEnumerator())
+				if (en.MoveNext())
+				{
+					TSource current;
+					do
+					{
+						current = en.Current;
+					} while (en.MoveNext());
+					return Equals(item, current);
+				}
+				else
+					return false;
+		}
+
+		/// <summary>
+		/// Checks, if <paramref name="item"/> is last element of <paramref name="source"/>.
+		/// </summary>
+		/// <typeparam name="TSource">The type of the elements of source.</typeparam>
+		/// <param name="source">An <see cref="IEnumerable{T}"/> to check.</param>
+		/// <param name="item">Source item to compare with last element.</param>
+		/// <param name="comparer">The comparer.</param>
+		/// <returns>
+		/// <c>true</c>, if <paramref name="source"/> has at least one element and last element is equals to
+		/// <paramref name="item"/>, otherwise <c>false</c>.
+		/// </returns>
+		public static bool IsLast<TSource>(
+			[NotNull] this IEnumerable<TSource> source,
+			TSource item,
+			[CanBeNull] IEqualityComparer<TSource> comparer)
+		{
+			Code.NotNull(source, nameof(source));
+
+			comparer = comparer ?? EqualityComparer<TSource>.Default;
+
+			// Fast path
+			// ReSharper disable once CollectionNeverUpdated.Local
+			if (source is IList<TSource> list)
+				return comparer.Equals(item, list[list.Count - 1]);
+
+			using (var en = source.GetEnumerator())
+				if (en.MoveNext())
+				{
+					TSource current;
+					do
+					{
+						current = en.Current;
+					} while (en.MoveNext());
+					return comparer.Equals(item, current);
+				}
+				else
+					return false;
+		}
 	}
 }

Main/tests/Collections/Enumerable/EnumerableExtensionTests.cs

@@ -30,5 +30,55 @@ public string Prepend1(string[] input, string prepend)
 		[TestCase(new[] {"1", "2"}, new[] {"-1", "0"}, TestName = "Prepend2 2", ExpectedResult = "-1, 0, 1, 2")]
 		public string Prepend(string[] input, string[] prepend)
 			=> input.Prepend(prepend).Join(", ");
+
+		[Test]
+		public void IsFirst()
+		{
+			var src = new[] { "a", "b", "c" };
+
+			// Fast path
+			Assert.IsTrue(src.IsFirst("a"), "#A01");
+			Assert.IsFalse(src.IsFirst("b"), "#A02");
+
+			Assert.IsTrue(src.IsFirst("a", null), "#A03");
+			Assert.IsFalse(src.IsFirst("A", null), "#A04");
+			Assert.IsTrue(src.IsFirst("A", StringComparer.OrdinalIgnoreCase), "#A05");
+
+			// Slow path
+			var enSrc = src.Select(i => i);
+			// ReSharper disable PossibleMultipleEnumeration
+			Assert.IsTrue(enSrc.IsFirst("a"), "#A06");
+			Assert.IsFalse(enSrc.IsFirst("b"), "#A07");
+
+			Assert.IsTrue(enSrc.IsFirst("a", null), "#A08");
+			Assert.IsFalse(enSrc.IsFirst("A", null), "#A09");
+			Assert.IsTrue(enSrc.IsFirst("A", StringComparer.OrdinalIgnoreCase), "#A10");
+			// ReSharper restore PossibleMultipleEnumeration
+		}
+
+		[Test]
+		public void IsLast()
+		{
+			var src = new[] { "a", "b", "c" };
+
+			// Fast path
+			Assert.IsTrue(src.IsLast("c"), "#A01");
+			Assert.IsFalse(src.IsLast("b"), "#A02");
+
+			Assert.IsTrue(src.IsLast("c", null), "#A03");
+			Assert.IsFalse(src.IsLast("C", null), "#A04");
+			Assert.IsTrue(src.IsLast("C", StringComparer.OrdinalIgnoreCase), "#A05");
+
+			// Slow path
+			var enSrc = src.Select(i => i);
+			// ReSharper disable PossibleMultipleEnumeration
+			Assert.IsTrue(enSrc.IsLast("c"), "#A06");
+			Assert.IsFalse(enSrc.IsLast("b"), "#A07");
+
+			Assert.IsTrue(enSrc.IsLast("c", null), "#A08");
+			Assert.IsFalse(enSrc.IsLast("C", null), "#A09");
+			Assert.IsTrue(enSrc.IsLast("C", StringComparer.OrdinalIgnoreCase), "#A10");
+			// ReSharper restore PossibleMultipleEnumeration
+		}
 	}
 }