replace empty char with new string,unsafe method和native implementation的性能比较

class Program
    {
        static void Main(string[] args)
        {
            string s = File.ReadAllText(@"e:\test.txt");
            Program p = new Program();
            string r6 = p.Replace_1(s, ' ', 'a');
            string r7 = p.Replace_2(s, " ", "a");
            string r1=p.ReplaceEmptyChar_1(s, "a");
            string r2 = p.ReplaceEmptyChar_2(s, "a");
            string r3 = p.ReplaceEmptyChar_3(s, "a");
            string r4 = p.ReplaceEmptyChar_4(s, "a");
            string r5 = p.ReplaceEmptyChar_5(s, 'a');
            string r8 = p.ReplaceEmptyChar_6(s, 'a');
            Console.WriteLine(string.Equals(r5, r7));
        }

        /// <summary>
        /// replace empty char with new string
        /// </summary>
        /// <param name="s">string to be dealed</param>
        /// <param name="to_be_replaced">replace with this string</param>
        /// <returns>new string</returns>
        public string ReplaceEmptyChar_1(string s,string to_be_replaced)
        {
            if (string.IsNullOrEmpty(s) || string.IsNullOrEmpty(to_be_replaced) || to_be_replaced==" ")
            {
                return s;
            }

            char[] charArray = s.ToCharArray();
            char[] replaceArray = to_be_replaced.ToCharArray();
            int replaced_length=to_be_replaced.Length;
            //get the empty count
            int emptyCount = 0;
            for (int i=0;i<charArray.Length;i++)
            {
                if (charArray[i] == ' ')
                {
                    emptyCount++;
                    if (replaced_length==1)
                    {
                        charArray[i] = replaceArray[0];
                    }
                }
            }


            if (emptyCount == 0)
            {
                return s;
            }

            //no need to resize array and return the new string directly
            if (replaced_length == 1)
            {
                return new string(charArray);
            }

            int newSeats = (replaced_length - 1) * emptyCount;
            int oldSize = charArray.Length;
            int newSize=oldSize+newSeats;
            Array.Resize<char>(ref charArray, newSize);
            for (int i = oldSize - 1; i >= 0; i--)
            {
                if (charArray[i] == ' ')
                {
                    for (int j = 0; j < replaced_length; j++)
                    {
                        charArray[newSize - j - 1] = to_be_replaced[replaced_length - j - 1];
                    }
                    newSize -=replaced_length ;
                }
                else
                {
                    charArray[newSize - 1] = charArray[i];
                    newSize--;
                }
            }

            return new string(charArray);
        }

        /// <summary>
        /// use string builder
        /// </summary>
        public string ReplaceEmptyChar_2(string s, string to_be_replaced)
        {
            StringBuilder sb=new StringBuilder();
            foreach(char c in s)
            {
                if (c == ' ')
                {
                    sb.Append(to_be_replaced);
                }
                else
                {
                    sb.Append(c);
                }
            }
            return sb.ToString();
        }

        /// <summary>
        /// use string builder
        /// </summary>
        public string ReplaceEmptyChar_3(string s, string to_be_replaced)
        {
            StringBuilder sb = new StringBuilder(s.Length*2);
            foreach (char c in s)
            {
                if (c == ' ')
                {
                    sb.Append(to_be_replaced);
                }
                else
                {
                    sb.Append(c);
                }
            }
            return sb.ToString();
        }

        /// <summary>
        /// use list
        /// </summary>
        public string ReplaceEmptyChar_4(string s, string to_be_replaced)
        {
            List<char> list = new List<char>(s.Length * 2);
            foreach (char c in s)
            {
                if (c == ' ')
                {
                    foreach (char c2 in to_be_replaced)
                    {
                        list.Add(c2);
                    }
                }
                else
                {
                    list.Add(c);
                }
            }
            return new string(list.ToArray());
        }

        /// <summary>
        /// unsafe pointer
        /// </summary>
        public unsafe string ReplaceEmptyChar_5(string s, char to_be_replaced)
        {
            int emptyCount = 0;
            fixed (char* c = s)
            {
                char* cp = c;
                for (int i = 0; i < s.Length; i++)
                {
                    if (*cp == ' ')
                    {
                        *cp = to_be_replaced;
                    }
                    cp++;
                }

                if (emptyCount == 0)
                {
                    return s;
                }
                return new string(c);
            }

        }

        public string ReplaceEmptyChar_6(string s, char to_be_replaced)
        {
            char[] charArray = s.ToCharArray();

            for (int i = 0; i < charArray.Length; i++)
            {
                if (charArray[i] == ' ')
                {
                    charArray[i] = to_be_replaced;
                }
            }
            return new string(charArray);
        }

        /// <summary>
        /// use string.Replace
        /// </summary>
        public string Replace_2(string s, string old, string to_be_replaced)
        {
            return s.Replace(old, to_be_replaced);
        }

        /// <summary>
        /// use string.Replace
        /// </summary>
        public string Replace_1(string s, char old, char to_be_replaced)
        {
            return s.Replace(old, to_be_replaced);
        }

        /****
         用指定字符串替换空白字符的三个实现比较，发现还是框架自带方法Replace快很多
         Reflector一下发现Replace实现在COMString.cpp中，native的优势~~~~~
         为了更深刻反映native的优势，通过ReplaceEmptyChar_5实现一个unsafe的方法，其中用到指针
         该方法只简单做字符替换，而Replace也有一个字符替换的重载，同时实现一个managed版本的字符替换方法ReplaceEmptyChar_6
         实现结果标明使用了unsfae的指针之后，性能也有较大提升
         ****/
    }