IEnumerable的扩展方法

       近期收集一些基于IEnumerable<T>扩展方法，它给我们带了很多便利，有时的确是实用的。其中有Alternate,Append,Prepend,Distinct,Contains。具体怎么用呢，看下面的UnitTest.

Code:

    /// <summary>
    /// IEnumerableExtension
    /// </summary>
    public static class IEnumerableExtensions
    {
        #region Methods (5)

        // Public Methods (5)

        /// <summary>
        /// Alternates the specified first.
        /// </summary>
        /// <typeparam name="TSource">The type of the source.</typeparam>
        /// <param name="first">The first.</param>
        /// <param name="second">The second.</param>
        /// <returns></returns>
        public static IEnumerable<TSource> Alternate<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
        {
            using (IEnumerator<TSource> e1 = first.GetEnumerator())
            using (IEnumerator<TSource> e2 = second.GetEnumerator())
                while (e1.MoveNext() && e2.MoveNext())
                {
                    yield return e1.Current;
                    yield return e2.Current;
                }
        }

        /// <summary>
        /// Appends the specified source.
        /// </summary>
        /// <typeparam name="TSource">The type of the source.</typeparam>
        /// <param name="source">The source.</param>
        /// <param name="element">The element.</param>
        /// <returns>IEnumerable<TSource></returns>
        public static IEnumerable<TSource> Append<TSource>(this IEnumerable<TSource> source, TSource element)
        {
            using (IEnumerator<TSource> e1 = source.GetEnumerator())
                while (e1.MoveNext())
                    yield return e1.Current;

            yield return element;
        }

        /// <summary>
        /// Determines whether [contains] [the specified source].
        /// </summary>
        /// <typeparam name="TSource">The type of the source.</typeparam>
        /// <typeparam name="TResult">The type of the result.</typeparam>
        /// <param name="source">The source.</param>
        /// <param name="value">The value.</param>
        /// <param name="selector">The selector.</param>
        /// <returns>
        ///     <c>true</c> if [contains] [the specified source]; otherwise, <c>false</c>.
        /// </returns>
        public static bool Contains<TSource, TResult>(
            this IEnumerable<TSource> source, TResult value, Func<TSource, TResult> selector)
        {
            foreach (TSource sourceItem in source)
            {
                TResult sourceValue = selector(sourceItem);
                if (sourceValue.Equals(value))
                    return true;
            }
            return false;
        }

        /// <summary>
        /// Distincts the specified source.
        /// </summary>
        /// <typeparam name="TSource">The type of the source.</typeparam>
        /// <typeparam name="TResult">The type of the result.</typeparam>
        /// <param name="source">The source.</param>
        /// <param name="comparer">The comparer.</param>
        /// <returns>IEnumerable<TSource></returns>
        public static IEnumerable<TSource> Distinct<TSource, TResult>(
     this IEnumerable<TSource> source, Func<TSource, TResult> comparer)
        {
            return source.Distinct(new DynamicComparer<TSource, TResult>(comparer));
        }

        /// <summary>
        /// Prepends the specified source.
        /// </summary>
        /// <typeparam name="TSource">The type of the source.</typeparam>
        /// <param name="source">The source.</param>
        /// <param name="element">The element.</param>
        /// <returns>IEnumerable<TSource></returns>
        public static IEnumerable<TSource> Prepend<TSource>(this IEnumerable<TSource> source, TSource element)
        {
            yield return element;

            using (IEnumerator<TSource> e1 = source.GetEnumerator())
                while (e1.MoveNext())
                    yield return e1.Current;
        }

        #endregion Methods
    }

    /// <summary>
    /// DynamicComparer
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <typeparam name="TResult">The type of the result.</typeparam>
    public class DynamicComparer<T, TResult> : IEqualityComparer<T>
    {
        #region Fields (1)

        private readonly Func<T, TResult> _selector;

        #endregion Fields

        #region Constructors (1)

        /// <summary>
        /// Initializes a new instance of the <see cref="DynamicComparer&lt;T, TResult&gt;"/> class.
        /// </summary>
        /// <param name="selector">The selector.</param>
        public DynamicComparer(Func<T, TResult> selector)
        {
            _selector = selector;
        }

        #endregion Constructors

        #region Methods (2)

        // Public Methods (2)

        /// <summary>
        /// Determines whether the specified objects are equal.
        /// </summary>
        /// <param name="x">The first object of type <paramref name="T"/> to compare.</param>
        /// <param name="y">The second object of type <paramref name="T"/> to compare.</param>
        /// <returns>
        /// true if the specified objects are equal; otherwise, false.
        /// </returns>
        public bool Equals(T x, T y)
        {
            TResult result1 = _selector(x);
            TResult result2 = _selector(y);
            return result1.Equals(result2);
        }

        /// <summary>
        /// Returns a hash code for the specified object.
        /// </summary>
        /// <param name="obj">The <see cref="T:System.Object"/> for which a hash code is to be returned.</param>
        /// <returns>A hash code for the specified object.</returns>
        /// <exception cref="T:System.ArgumentNullException">
        /// The type of <paramref name="obj"/> is a reference type and <paramref name="obj"/> is null.
        /// </exception>
        public int GetHashCode(T obj)
        {
            TResult result = _selector(obj);
            return result.GetHashCode();
        }

        #endregion Methods
    }

UnitTest:

    #region Methods (8)

        // Public Methods (7)

        [Test]
        public void Bad_concat_method()
        {
            var ints = new[] { 1, 2, 3 };

            var oneToFour = ints.Concat(Enumerable.Repeat(4, 1));

            CollectionAssert.AreEqual(new[] { 1, 2, 3, 4 }, oneToFour.ToArray());
        }

        [Test]
        public void Better_enumerable_extensions()
        {
            var values = new[]
                             {
                                 new Person {FirstName = "Bob", LastName = "Smith"},
                                 new Person {FirstName = "Don", LastName = "Allen"},
                                 new Person {FirstName = "Bob", LastName = "Sacamano"},
                                 new Person {FirstName = "Chris", LastName = "Smith"},
                                 new Person {FirstName = "George", LastName = "Allen"}
                             };

            Assert.AreEqual(3, values.Distinct(person => person.LastName).Count());
            Assert.AreEqual(4, values.Distinct(person => person.FirstName).Count());
            Assert.IsTrue(values.Contains("Smith", person => person.LastName));
            Assert.IsFalse(values.Contains("Nixon", person => person.LastName));
        }

        [Test]
        public void Easier_concat_with_append()
        {
            var ints = new[] { 1, 2, 3 };

            var oneToFour = ints.Append(4);

            CollectionAssert.AreEqual(new[] { 1, 2, 3, 4 }, oneToFour.ToArray());
        }

        [Test]
        public void Easier_concat_with_prepend()
        {
            var ints = new[] { 1, 2, 3 };

            var zeroToThree = ints.Prepend(0);

            CollectionAssert.AreEqual(new[] { 0, 1, 2, 3 }, zeroToThree.ToArray());
        }

        [Test]
        public void TestAggregate()
        {
            string sentence = "the quick brown fox jumps over the lazy dog";

            // Split the string into individual words.
            string[] words = sentence.Split(' ');

            // Prepend each word to the beginning of the
            // new sentence to reverse the word order.
            string reversed = words.Aggregate((workingSentence, next) =>
                                                  next + " " + workingSentence);
            Assert.AreEqual("dog lazy the over jumps fox brown quick the",reversed);
        }

        [Test]
        public void TestintArray()
        {
            int[] aa = new int[] { 1, 3, 5};
            int[] bb = new int[] { 2, 4, 6 };

            var cc = aa.Alternate(bb);

            CollectionAssert.AreEqual(new[] { 1, 2, 3, 4, 5, 6},cc.ToArray());

        }

        [Test]
        public void Word_play()
        {
            var source = new[] { "That", "is", "exactly", "I", "want" };

            var result = source.Alternate(Spaces()).Aggregate(string.Empty, (a, b) => a + b);


            foreach (var s in result)
            {
                Console.Write(s);
            }
            //That is exactly I want
        }
        // Private Methods (1)

        private IEnumerable<string> Spaces()
        {
            while (true)
                yield return " ";
        }

        #endregion Methods

Author:Petter Liu   http://wintersun.cnblogs.com  

希望这篇Post对您有帮助。