一个LINQ风格的Replace扩展方法

       在微软的.net framework框架中我们知道String有一个Replace的方法，今天我们来实现一个LINQ风格的基于集合Replace元素的扩展方法。首先来看一下，简单类图:

     下面是主要代码片断：

   /// <summary>
    /// ReplaceExtensions which is LINQ Style Replace Operator
    /// </summary>
    public static class ReplaceExtensions
    {
        /// <summary>
        /// Replaces the specified sequence.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sequence">The sequence.</param>
        /// <param name="find">The find.</param>
        /// <param name="replaceWith">The replace with.</param>
        /// <param name="comparer">The comparer.</param>
        /// <returns>Collection of type T</returns>
        public static IEnumerable<T> Replace<T>(
    this IEnumerable<T> sequence, T find, T replaceWith, IEqualityComparer<T> comparer)
        {
            if (sequence == null) throw new ArgumentNullException("sequence");
            if (comparer == null) throw new ArgumentNullException("comparer");

            return ReplaceImpl(sequence, find, replaceWith, comparer);
        }

        /// <summary>
        /// Replaces the specified sequence.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sequence">The sequence.</param>
        /// <param name="find">The find.</param>
        /// <param name="replaceWith">The replace with.</param>
        /// <returns>Collection of type T</returns>
        public static IEnumerable<T> Replace<T>(
    this IEnumerable<T> sequence, T find, T replaceWith)
        {
            return Replace(sequence, find, replaceWith, EqualityComparer<T>.Default);
        }

        /// <summary>
        /// Replaces the impl.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sequence">The sequence.</param>
        /// <param name="find">The find.</param>
        /// <param name="replaceWith">The replace with parameter</param>
        /// <param name="comparer">The comparer.</param>
        /// <returns>Collection of type T</returns>
        private static IEnumerable<T> ReplaceImpl<T>(
    IEnumerable<T> sequence, T find, T replaceWith, IEqualityComparer<T> comparer)
        {
            foreach (T item in sequence)
            {
                bool match = comparer.Equals(find, item);
                T x = match ? replaceWith : item;
                yield return x;
            }
        }
    }

从代码应该不难看懂，我们使用IEqualityComparer<T>，  然后Equals, 接着使用了yield， 您可以根据需求实现自己的实现类。这样我们就能实现类似LINQ风格的Replace集合元素扩展，看下面的UnitTest:

        [TestMethod]
        public void Single_IntCollection_Replace_Should_Same()
        {
            //Arranage
            int[] values = new int[] { 1, 2, 3, 4, 5, 4, 3, 2, 1 };

            //Act
            int[] replaced = values.Replace(3, 0).ToArray();

            //Assert
            CollectionAssert.AreEqual(new int[] { 1, 2, 0, 4, 5, 4, 0, 2, 1 }, replaced,"Results should be same.");
        }

        [TestMethod]
        public void StringCollection_Replace_Should_Same()
        {
            //Arrange
            string[] strings = new string[] { "A", "B", "C", "D", "a", "b", "c", "d" };

            //Act
            string[] replacedCS = strings.Replace("b", "-").ToArray();
            string[] replacedCI = strings.Replace("b", "-", StringComparer.InvariantCultureIgnoreCase).ToArray();

            //Assert
            CollectionAssert.AreEqual(new string[] { "A", "B", "C", "D", "a", "-", "c", "d" }, replacedCS, "Results should be same.");
            CollectionAssert.AreEqual(new string[] { "A", "-", "C", "D", "a", "-", "c", "d" }, replacedCI, "Results should be same.");
        }

基于MsTest的单元测试，您了解的话，应该不难看懂上面的代码。
希望对您CSharp编码有帮助。

您可能感兴趣的文章:

为IEnumerable<T>增加Combine的扩展方法
IEnumerable的扩展方法

作者：Petter Liu
出处：http://www.cnblogs.com/wintersun/
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。
该文章也同时发布在我的独立博客中-Petter Liu Blog。