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

   1:  class Program

   2:      {

   3:          static void Main(string[] args)

   4:          {

   5:              string s = File.ReadAllText(@"e:\test.txt");

   6:              Program p = new Program();

   7:              string r6 = p.Replace_1(s, ' ', 'a');

   8:              string r7 = p.Replace_2(s, " ", "a");

   9:              string r1=p.ReplaceEmptyChar_1(s, "a");

  10:              string r2 = p.ReplaceEmptyChar_2(s, "a");

  11:              string r3 = p.ReplaceEmptyChar_3(s, "a");

  12:              string r4 = p.ReplaceEmptyChar_4(s, "a");

  13:              string r5 = p.ReplaceEmptyChar_5(s, 'a');

  14:              string r8 = p.ReplaceEmptyChar_6(s, 'a');

  15:              Console.WriteLine(string.Equals(r5, r7));

  16:          }

  17:   

  18:          /// <summary>

  19:          /// replace empty char with new string

  20:          /// </summary>

  21:          /// <param name="s">string to be dealed</param>

  22:          /// <param name="to_be_replaced">replace with this string</param>

  23:          /// <returns>new string</returns>

  24:          public string ReplaceEmptyChar_1(string s,string to_be_replaced)

  25:          {

  26:              if (string.IsNullOrEmpty(s) || string.IsNullOrEmpty(to_be_replaced) || to_be_replaced==" ")

  27:              {

  28:                  return s;

  29:              }

  30:   

  31:              char[] charArray = s.ToCharArray();

  32:              char[] replaceArray = to_be_replaced.ToCharArray();

  33:              int replaced_length=to_be_replaced.Length;

  34:              //get the empty count

  35:              int emptyCount = 0;

  36:              for (int i=0;i<charArray.Length;i++)

  37:              {

  38:                  if (charArray[i] == ' ')

  39:                  {

  40:                      emptyCount++;

  41:                      if (replaced_length==1)

  42:                      {

  43:                          charArray[i] = replaceArray[0];

  44:                      }

  45:                  }

  46:              }

  47:   

  48:   

  49:              if (emptyCount == 0)

  50:              {

  51:                  return s;

  52:              }

  53:   

  54:              //no need to resize array and return the new string directly

  55:              if (replaced_length == 1)

  56:              {

  57:                  return new string(charArray);

  58:              }

  59:   

  60:              int newSeats = (replaced_length - 1) * emptyCount;

  61:              int oldSize = charArray.Length;

  62:              int newSize=oldSize+newSeats;

  63:              Array.Resize<char>(ref charArray, newSize);

  64:              for (int i = oldSize - 1; i >= 0; i--)

  65:              {

  66:                  if (charArray[i] == ' ')

  67:                  {

  68:                      for (int j = 0; j < replaced_length; j++)

  69:                      {

  70:                          charArray[newSize - j - 1] = to_be_replaced[replaced_length - j - 1];

  71:                      }

  72:                      newSize -=replaced_length ;

  73:                  }

  74:                  else

  75:                  {

  76:                      charArray[newSize - 1] = charArray[i];

  77:                      newSize--;

  78:                  }

  79:              }

  80:   

  81:              return new string(charArray);

  82:          }

  83:   

  84:          /// <summary>

  85:          /// use string builder

  86:          /// </summary>

  87:          public string ReplaceEmptyChar_2(string s, string to_be_replaced)

  88:          {

  89:              StringBuilder sb=new StringBuilder();

  90:              foreach(char c in s)

  91:              {

  92:                  if (c == ' ')

  93:                  {

  94:                      sb.Append(to_be_replaced);

  95:                  }

  96:                  else

  97:                  {

  98:                      sb.Append(c);

  99:                  }

 100:              }

 101:              return sb.ToString();

 102:          }

 103:   

 104:          /// <summary>

 105:          /// use string builder

 106:          /// </summary>

 107:          public string ReplaceEmptyChar_3(string s, string to_be_replaced)

 108:          {

 109:              StringBuilder sb = new StringBuilder(s.Length*2);

 110:              foreach (char c in s)

 111:              {

 112:                  if (c == ' ')

 113:                  {

 114:                      sb.Append(to_be_replaced);

 115:                  }

 116:                  else

 117:                  {

 118:                      sb.Append(c);

 119:                  }

 120:              }

 121:              return sb.ToString();

 122:          }

 123:   

 124:          /// <summary>

 125:          /// use list

 126:          /// </summary>

 127:          public string ReplaceEmptyChar_4(string s, string to_be_replaced)

 128:          {

 129:              List<char> list = new List<char>(s.Length * 2);

 130:              foreach (char c in s)

 131:              {

 132:                  if (c == ' ')

 133:                  {

 134:                      foreach (char c2 in to_be_replaced)

 135:                      {

 136:                          list.Add(c2);

 137:                      }

 138:                  }

 139:                  else

 140:                  {

 141:                      list.Add(c);

 142:                  }

 143:              }

 144:              return new string(list.ToArray());

 145:          }

 146:   

 147:          /// <summary>

 148:          /// unsafe pointer

 149:          /// </summary>

 150:          public unsafe string ReplaceEmptyChar_5(string s, char to_be_replaced)

 151:          {

 152:              int emptyCount = 0;

 153:              fixed (char* c = s)

 154:              {

 155:                  char* cp = c;

 156:                  for (int i = 0; i < s.Length; i++)

 157:                  {

 158:                      if (*cp == ' ')

 159:                      {

 160:                          *cp = to_be_replaced;

 161:                      }

 162:                      cp++;

 163:                  }

 164:   

 165:                  if (emptyCount == 0)

 166:                  {

 167:                      return s;

 168:                  }

 169:                  return new string(c);

 170:              }

 171:   

 172:          }

 173:   

 174:          public string ReplaceEmptyChar_6(string s, char to_be_replaced)

 175:          {

 176:              char[] charArray = s.ToCharArray();

 177:   

 178:              for (int i = 0; i < charArray.Length; i++)

 179:              {

 180:                  if (charArray[i] == ' ')

 181:                  {

 182:                      charArray[i] = to_be_replaced;

 183:                  }

 184:              }

 185:              return new string(charArray);

 186:          }

 187:   

 188:          /// <summary>

 189:          /// use string.Replace

 190:          /// </summary>

 191:          public string Replace_2(string s, string old, string to_be_replaced)

 192:          {

 193:              return s.Replace(old, to_be_replaced);

 194:          }

 195:   

 196:          /// <summary>

 197:          /// use string.Replace

 198:          /// </summary>

 199:          public string Replace_1(string s, char old, char to_be_replaced)

 200:          {

 201:              return s.Replace(old, to_be_replaced);

 202:          }

 203:   

 204:          /****

 205:           用指定字符串替换空白字符的三个实现比较，发现还是框架自带方法Replace快很多

 206:           Reflector一下发现Replace实现在COMString.cpp中，native的优势~~~~~

 207:           为了更深刻反映native的优势，通过ReplaceEmptyChar_5实现一个unsafe的方法，其中用到指针

 208:           该方法只简单做字符替换，而Replace也有一个字符替换的重载，同时实现一个managed版本的字符替换方法ReplaceEmptyChar_6

 209:           实现结果标明使用了unsfae的指针之后，性能也有较大提升

 210:           ****/

 211:      }

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, "Courier New", courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }