C#里面滥用String造成的性能问题

前两天给我们的json写一个解析函数, 之前用的正宗的json parser, 支持完整的json特性. 但是实际上我们用到特性, 只有key-value的映射, value的类型只有数字和字符串两种类型. 由于parse的速度比较慢, 所以我打算自己用字符串解析一遍. 第一个能工作的原型出来的时候, 速度和json解析差不多. 做了profile之后发现, 绝大部分时间都浪费在构造String和检索IndexOf上面.

下了coreclr的源码研究了一下, 发现String.Split在实现的时候, 先扫描一遍split, 计算有多少个元素, 然后分配一个Array, 然后再去做Split操作. Split操作里面还会再new一个新的String出来, 顺便做一下拷贝. 看到这里我就惊呆了, 本来String在C#和Jawa这两个托管语言里面都是不可变的, 那么为什么他们不用一个Slice去构造一个SubString呢?

网上搜了一下, 也没发现有人写的StringSlice或者类似的东西, 我就顺手撸了一个StringView, 一个只读的StringSlice.

 using System.Collections.Generic;
 
 public unsafe struct StringView
 {
     public static readonly StringView Empty = new StringView("");
 
     public StringView(string str) : this(str, , str.Length) { }
 
     public StringView(string str, int begin, int length)
     {
         this.str = str;
         this.begin = begin;
         this.length = length;
         if (str.Length <= ) return;
 
         if (this.begin <  ||
             this.begin >= this.str.Length ||
             this.begin + this.length > this.str.Length)
         {
             throw new System.Exception("StringView's Constructor OutOfBound");
         }
     }
 
     public int IndexOf(char c, int start = )
     {
         fixed (char* p = this.str)
         {
             for (int i = start; i < length; ++i)
             {
                 if (p[this.begin + i] == c) return i;
             }
         }
 
         return -;
     }
 
     private static bool ArrayContains(char[] array, char c)
     {
         int length = array.Length;
         fixed (char* p = array)
         {
             for (int i = ; i < length; ++i)
                 if (p[i] == c) return true;
         }
 
         return false;
     }
 
     public int IndexOf(char[] array, int start = )
     {
         if (array.Length == ) return this.IndexOf(array[], start);
 
         fixed (char* p = this.str)
         {
             for (int i = start; i < length; ++i)
             {
                 if (ArrayContains(array, p[this.begin + i])) return i;
             }
         }
 
         return -;
     }
 
     public int IndexOf(string s, int start = )
     {
         int s1_length = this.str.Length;
         int s2_length = s.Length;
         fixed (char* p1 = this.str)
         {
             fixed (char* p2 = s)
             {
                 int index = this.IndexOf(p2[], start);
                 while (index >= )
                 {
                     if (s2_length > s1_length - this.begin - index)
                         return -;
                     bool match = true;
                     for (int i = ; i < s2_length; ++i)
                     {
                         if (p1[this.begin + index + i] != p2[i]) { match = false; break; }
                     }
                     if (match) return index;
 
                     index = this.IndexOf(p2[], index + );
                 }
                 return -;
             }
         }
     }
 
     public unsafe char this[int index]
     {
         get
         {
             if (index <  || index >= this.length)
             {
                 throw new System.Exception("StringView's Index OutOfBound");
             }
 
             fixed (char* p = this.str)
             {
                 return p[this.begin + index];
             }
         }
     }
 
     public StringView SubString(int begin)
     {
         return this.SubString(begin, this.length - begin);
     }
 
     public StringView SubString(int begin, int length)
     {
         return new StringView(this.str, this.begin + begin, length);
     }
 
     public List<StringView> Split(char split, List<StringView> array)
     {
         array.Clear();
 
         int index = ;
         int pos1 = , pos2 = ;
         pos2 = this.IndexOf(split);
         while (pos2 >  && pos2 < this.length)
         {
             array.Add(new StringView(str, this.begin + pos1, pos2 - pos1));
             pos1 = pos2 + ;
             pos2 = this.IndexOf(split, pos1);
             ++index;
         }
         if (pos1 != this.length) array.Add(new StringView(str, this.begin + pos1, this.length - pos1));
 
         return array;
     }
 
     public override bool Equals(object obj)
     {
         if (obj is StringView)
         {
             StringView v = (StringView)obj;
             return this.Equals(v);
         }
         return false;
     }
 
     public bool Equals(StringView v)
     {
         if (v.Length != this.Length) return false;
         for (int i = ; i < this.Length; ++i)
         {
             if (this[i] != v[i]) return false;
         }
         return true;
     }
 
     internal static int CombineHashCodes(int h1, int h2)
     {
         return (((h1 << ) + h1) ^ h2);
     }
 
     public override int GetHashCode()
     {
         int hash_code = ;
         for (int i = ; i < this.length; ++i)
         {
             hash_code = CombineHashCodes(hash_code, this[i].GetHashCode());
         }
         return hash_code;
     }
 
     public int Length { get { return this.length; } }
 
     public override string ToString()
     {
         return this.str.Substring(begin, length);
     }
 
     public string GetRawString() { return this.str; }
     public int GetBegin() { return this.begin; }
 
     private string str;
     private int begin;
     private int length;
 }

为了方便替换String, 很多接口都保持了一致. 目前这个版本只是满足我自己的需求, 以后可以考虑继续完善添加String的函数进来.

之前说的IndexOf也比较耗, 因为String的索引器会带有边界检测, 而IndexOf一直在用索引器, 所以个人感觉是不太合适的, 所以我的StringView一直在用指针….

PS: 修改之后的纯text parse, 速度比json parse的速度快一倍以上, 性能还不错, 实际上还有提升的空间

PS: 现在比较完整的StringView已经上传至github, https://github.com/egmkang/StringView 添加了ToInt64, StringBuilder.Append支持