C#程序员应该养成的程序性能优化写法

曾经在网上听过这样一句话

程序的可读性和性能是成反比的

我非常赞同这句话,所以对于那些极度影响阅读的性能优化我就不在这里赘述了

今天主要说的就是一些举手之劳即可完成的性能优化

减少重复代码

这是最基本的优化方案,尽可能减少那些重复做的事,让他们只做一次

比较常见是这种代码,同样的math.cos(angle) 和math.sin(angle)都做了2次

优化前

private point rotatept(double angle, point pt)
{
   point pret = new point();
   angle = -angle;
   pret.x = (int)((double)pt.x * math.cos(angle) - (double)pt.y * math.sin(angle));
   pret.y = (int)((double)pt.x * math.sin(angle) + (double)pt.y * math.cos(angle));
   return pret;
}

优化后

private point rotatept3(double angle, point pt)
{
  point pret = new point();
  angle = -angle;
  double sin_angle = math.sin(angle);
  double cos_angle = math.cos(angle);
  pret.x =(int)(pt.x * cos_angle - pt.y * sin_angle);
  pret.y = (int)(pt.x * sin_angle + pt.y * cos_angle);
  return pret;
}

还有另一种 ,在方法中实例化一个对象, 但是这个对象其实是可以复用的

public static string convertquot(string html)
{
  regex regex = new regex("&(quot|#34);", regexoptions.ignorecase);
  return regex.replace(html, "\"");
}

优化后

readonly static regex replacequot = new regex("&(quot|#34);", regexoptions.ignorecase | regexoptions.compiled);
public static string convertquot(string html)
{
  return replacequot.replace(html, "\"");
}

还有一种是不必要的初始化,比如调用out参数之前,是不需要初始化的

public bool check(int userid)
{
  var user = new user();
  if(getuser(userid,out user))
  {
    return user.level > 1;
  }
  return false;
}

这里的new user()就是不必要的操作,

优化后

public bool check(int userid)
{
  user user;
  if(getuser(userid,out user))
  {
    return user.level > 1;
  }
  return false;
}

不要迷信正则表达式

正好在第一个栗子里说到了正在表达式(regex)对象就顺便一起说了

很多人以为正则表达式很快,非常快,超级的快

虽然正则表达式是挺快的,不过千万不要迷信他,不信你看下面的栗子

//方法1
public static string convertquot1(string html)
{
  return html.replace(""", "\"").replace(""", "\"");
}
 
readonly static regex replacequot = new regex("&(quot|#34);", regexoptions.ignorecase | regexoptions.compiled);
//方法2
public static string convertquot2(string html)
{
  return replacequot.replace(html, "\"");
}

有多少人认为正则表达式比较快的,举个手??

结果为10w次循环的时间 ,即使是10个replace连用,也比regex好,所以不要迷信他

//方法1
public static string convertquot1(string html)
{
  return html.replace("0", "").replace("1", "").replace("2", "").replace("3", "").replace("4", "").replace("5", "").replace("6", "").replace("7", "").replace("8", "").replace("9", "");
}
 
readonly static regex replacequot = new regex("[1234567890]", regexoptions.ignorecase | regexoptions.compiled);
//方法2
public static string convertquot2(string html)
{
  return replacequot.replace(html, "");
}

convertquot1:3518
convertquot2:12479

最后给你们看一个真实的,杯具的栗子

htmlstring = regex.replace(htmlstring, @"<(.[^>]*)>", "", regexoptions.ignorecase);
htmlstring = regex.replace(htmlstring, @"([\r\n])[\s]+", "", regexoptions.ignorecase);
htmlstring = regex.replace(htmlstring, @"-->", "", regexoptions.ignorecase);
htmlstring = regex.replace(htmlstring, @"<!--.*", "", regexoptions.ignorecase);
 
htmlstring = regex.replace(htmlstring, @"&(quot|#34);", "\"", regexoptions.ignorecase);
htmlstring = regex.replace(htmlstring, @"&(amp|#38);", "&", regexoptions.ignorecase);
htmlstring = regex.replace(htmlstring, @"&(lt|#60);", "<", regexoptions.ignorecase);
htmlstring = regex.replace(htmlstring, @"&(gt|#62);", ">", regexoptions.ignorecase);
htmlstring = regex.replace(htmlstring, @"&(nbsp|#160);", " ", regexoptions.ignorecase);
htmlstring = regex.replace(htmlstring, @"&(iexcl|#161);", "\xa1", regexoptions.ignorecase);
htmlstring = regex.replace(htmlstring, @"&(cent|#162);", "\xa2", regexoptions.ignorecase);
htmlstring = regex.replace(htmlstring, @"&(pound|#163);", "\xa3", regexoptions.ignorecase);
htmlstring = regex.replace(htmlstring, @"&(copy|#169);", "\xa9", regexoptions.ignorecase);
htmlstring = regex.replace(htmlstring, @"(\d+);", "", regexoptions.ignorecase);

合理使用正则表达式

上面说了正则表达式的效率不高,并不是说就不要用他了,至少正则表达式的作用不仅仅如此而已

如果一定要用正则表达式的话也需要注意,能静态全局公用的尽量全局公用

readonly static regex regex = new regex("[1234567890]", regexoptions.compiled);

注意他的第二个参数regexoptions.compiled 注释是 指定将正则表达式编译为程序集。这会产生更快的执行速度，但会增加启动时间。

通俗的说就是加了这个枚举,会使得初始化regex对象变慢,但是执行字符串查找的时候更快, 不使用的话,初始化很多,查询比较慢

之前测过相差蛮大的 ,代码就不比较了,有兴趣的可以自己试试相差多少

另外还有一些枚举项,不确定是否对性能有影响,不过还是按规则使用会比较好

• regexoptions.ignorecase    // 指定不区分大小写的匹配,  如果表达式中没有字母,则不需要设定
• regexoptions.multiline         // 多行模式。更改 ^ 和 $ 的含义….  如果表达式中没有^和$,则不需要设定
• regexoptions.singleline       // 指定单行模式。更改点 (.) 的含义….  如果表达式中没有.,则不需要设定

让编译器预处理常量的计算

编译器在编译程序段的时候 如果发现有一些运算是常量对常量的,那么他会在编译期间就计算完成,这样可以使程序在执行时不用重复计算了

比如

不过编译器有的时候也不是那么聪明的

这个时候就需要我们帮助一下了

给他加一个括号,让他知道应该先计算常量,这样就可以在编译期间进行运算了

字符串比较

这个可能很多人知道了,但还是提一下

string s = "";
1) if(s == ""){}
2) if(s == string.empty){}
3) if (string.isnullorempty(s)) { }
4) if(s != null && s.length ==0) {}
5) if((s+"").length == 0){}

1,2最慢 3较快 4,5最快

1,2几乎没区别 4,5几乎没区别

不过这个只适用于比较null和空字符串,如果是连续的空白就是string.isnullorwhitespace最快了,不过这个方法2.0里面没有

所以2.0可以这样 (s+””).trim() == 0

这里的关键就是 s + “” 这个操作可以把null转换为””

注意第二个参数只能是””或string.empty 这样的累加几乎是不消耗时间的,如果第二个参数是” “(一个空格)这个时间就远远不止了

字符串拼接

字符串累加,这个道理和regex一样,不要盲目崇拜stringbuilder

在大量(或不确定的)string拼接的时候,stringbuilder确实可以起到提速的作用

而少数几个固定的string累加的时候就不需要stringbuilder 了,毕竟stringbuilder 的初始化也是需要时间的

感谢残蛹 博友提供的说明

ps: 这段我确实记得我是写过的来着,不知道怎么的,发出来的时候就不见了…..

此外还有一个string.concat方法,该方法可以小幅度的优化程序的速度,幅度很小

他和string.join的区别在于没有间隔符号(我之前常用string.join(“”,a,b,c,d),不要告诉我只有我一个人这么干)

另一种经常遇到的字符串拼接

public string joinids(list<user> users)
{
  stringbuilder sb = new stringbuilder();
  foreach (var user in users)
  {
    sb.append("'");
    sb.append(user.id);
    sb.append("',");
  }
  sb.length = sb.length - 1;
  return sb.tostring();
}

对于这种情况有2中优化的方案

对于3.5以上可以直接使用linq辅助,这种方案代码少,但是性能相对差一些

public string joinids(list<user> users)
{
  return "'" + string.join("','", users.select(it => it.id)) + "'";
}

对于非3.5或对性能要求极高的场合

public string joinids(list<user> users)
{
  var ee = users.getenumerator();
  stringbuilder sb = new stringbuilder();
  if (ee.movenext())
  {
    sb.append("'");
    sb.append(ee.current.id);
    sb.append("'");
    while (ee.movenext())
    {
      sb.append(",'");
      sb.append(ee.current.id);
      sb.append("'");
    }
  }
  return sb.tostring();
}

bool类型的判断返回

这种现象常见于新手程序员中

//写法1
if(state == 1)
{
  return true;
}
else
{
  return false;
}
//写法2
return state == 1 ? true : false;
//优化后
return state == 1;

类型的判断

一般类型的判断有2种形式

1,这种属于代码比较好写,但是性能比较低, 原因就是gettype()的时候消耗了很多时间

type type = obj.gettype();
switch (type.name)
{
  case "int32":
    break;
  case "string":
    break;
  case "boolean":
    break;
  case "datetime":
    break;
  ...
  ...
  default:
    break;
}

2,这种属性写代码麻烦,但是性能很高的类型

if (obj is string)
{
 
}
else if (obj is int)
{
 
}
else if (obj is datetime)
{
 
}
...
...
else
{
 
}

其实有个中间之道,既可以保证性能又可以比较好写

iconvertible conv = obj as iconvertible;
if (conv != null)
{
  switch (conv.gettypecode())
  {
    case typecode.boolean:
      break;
    case typecode.byte:
      break;
    case typecode.char:
      break;
    case typecode.dbnull:
      break;
    case typecode.datetime:
      break;
    case typecode.decimal:
      break;
    case typecode.double:
      break;
    case typecode.empty:
      break;
    case typecode.int16:
      break;
    case typecode.int32:
      break;
    ...
    ...
    default:
      break;
  }
}
else
{
  //处理其他类型
}

大部分情况下 这个是可以用的 如果你自己有个类型实现了iconvertible,然后返回typecode.int32 就不再这个讨论范围之内了

使用枚举作为索引

下面这个是一个真实的例子,为了突出重点,做了部分修改,删除了多余的分支,源代码中不只4个

enum templatecode
{
  none = 0,
  head = 1,
  menu = 2,
  foot = 3,
  welcome = 4,
}
 
public string gethtml(templatecode tc)
{
  switch (tc)
  {
    case templatecode.head:
      return gethead();
    case templatecode.menu:
      return getmenu();
    case templatecode.foot:
      return getfoot();
    case templatecode.welcome:
      return getwelcome();
    default:
      throw new argumentoutofrangeexception("tc");
  }
}

优化后

readonly static func<string>[] gettemplate = inittemplatefunction();
 
private static func<string>[] inittemplatefunction()
{
  var arr = new func<string>[5];
  arr[1] = gethead;
  arr[2] = getmenu;
  arr[3] = getfoot;
  arr[4] = getwelcome;
  return arr;
}
 
public string gethtml(templatecode tc)
{
  var index = (int)tc;
  if (index >= 1 && index <= 4)
  {
    return gettemplate[index]();
  }
  throw new argumentoutofrangeexception("tc");
}

不过有的时候,枚举不一定都是连续的数字,那么也可以使用dictionary

readonly static dictionary<templatecode, func<string>> templatedict = inittemplatefunction();
 
private static dictionary<templatecode, func<string>> inittemplatefunction()
{
  var ditc = new dictionary<templatecode, func<string>>();
  ditc.add(templatecode.head, gethead);
  ditc.add(templatecode.menu, getmenu);
  ditc.add(templatecode.foot, getfoot);
  ditc.add(templatecode.welcome, getwelcome);
  return ditc;
}
 
public string gethtml(templatecode tc)
{
  func<string> func;
  if (templatedict.trygetvalue(tc,out func))
  {
    return func();
  }
  throw new argumentoutofrangeexception("tc");
}

这种优化在分支比较多的时候很好用,少的时候作用有限

字符类型char,分支判断时的处理技巧

这部分内容比较复杂,而且适用范围有限,如果平时用不到的就可以忽略了

在处理字符串对象的时候,有时会需要判断char的值然后做进一步的操作

public string show(char c)
{
  if (c >= '0' && c <= '9')
  {
    return "数字";
  }
  else if (c >= 'a' && c <= 'z')
  {
    return "小写字母";
  }
  else if (c >= 'a' && c <= 'z')
  {
    return "大写字母";
  }
  else if (c == '/' || c == '\\' || c == '|'
    || c == '$' || c == '#' || c == '+'
    || c == '%' || c == '&' || c == '-'
    || c == '^' || c == '*' || c == '=')
  {
    return "特殊符号";
  }
  else if (c == ',' || c == '.' || c == '!'
    || c == ':' || c == ';' || c == '?'
    || c == '"' || c == '\'')
  {
    return "标点符号";
  }
  else
  {
    return "其他";
  }
}

这里有一种空间换时间的优化方式, 虽说是空间换时间,但是实际浪费的空间不会很多,因为char最多只有65536长度

readonly static byte[] charmap = initcharmap();
 
private static byte[] initcharmap()
{
  var arr = new byte[char.maxvalue];
  for (char i = '0'; i <= '9'; i++)
  {
    arr[i] = 1;
  }
  for (char i = 'a'; i <= 'z'; i++)
  {
    arr[i] = 2;
  }
  for (char i = 'a'; i <= 'z'; i++)
  {
    arr[i] = 3;
  }
  arr['/'] = 4;
  arr['\\'] = 4;
  arr['|'] = 4;
  arr['$'] = 4;
  arr['#'] = 4;
  arr['+'] = 4;
  arr['%'] = 4;
  arr['&'] = 4;
  arr['-'] = 4;
  arr['^'] = 4;
  arr['*'] = 4;
  arr['='] = 4;
 
  arr[','] = 5;
  arr['.'] = 5;
  arr['!'] = 5;
  arr[':'] = 5;
  arr[';'] = 5;
  arr['?'] = 5;
  arr['"'] = 5;
  arr['\''] = 5;
  return arr;
}
 
public string show(char c)
{
  switch (charmap[c])
  {
    case 0:
      return "其他";
    case 1:
      return "数字";
    case 2:
      return "小写字母";
    case 3:
      return "大写字母";
    case 4:
      return "特殊符号";
    case 5:
      return "标点符号";
    default:
      return "其他";
  }
}

原先仅特殊符号一部分就需要判断12次,修改过后只判断一次就可以得到结果了

这方面的栗子在我的json组件()(文章,,3)中也有使用

摘取部分blqw.json的代码

/// <summary>
/// <para>包含1: 可以为头的字符</para>
/// <para>包含2: 可以为单词的字符</para>
/// <para>包含4: 可以为数字的字符</para>
/// <para>等于8: 空白字符</para>
/// <para>包含16:转义字符</para>
/// <para></para>
/// </summary>
private readonly static byte[] _wordchars = new byte[char.maxvalue];
private readonly static sbyte[] _unicodeflags = new sbyte[123];
private readonly static sbyte[, ,] _datetimewords;
static unsafejsonreader()
{
  for (int i = 0; i < 123; i++)
  {
    _unicodeflags[i] = -1;
  }
 
  _wordchars['-'] = 1 | 4;
  _wordchars['+'] = 1 | 4;
 
  _wordchars['$'] = 1 | 2;
  _wordchars['_'] = 1 | 2;
  for (char c = 'a'; c <= 'z'; c++)
  {
    _wordchars[c] = 1 | 2;
    _unicodeflags[c] = (sbyte)(c - 'a' + 10);
  }
  for (char c = 'a'; c <= 'z'; c++)
  {
    _wordchars[c] = 1 | 2;
    _unicodeflags[c] = (sbyte)(c - 'a' + 10);
  }
 
  _wordchars['.'] = 1 | 2 | 4;
  for (char c = '0'; c <= '9'; c++)
  {
    _wordchars[c] = 4;
    _unicodeflags[c] = (sbyte)(c - '0');
  }
 
  //科学计数法
  _wordchars['e'] |= 4;
  _wordchars['e'] |= 4;
 
  _wordchars[' '] = 8;
  _wordchars['\t'] = 8;
  _wordchars['\r'] = 8;
  _wordchars['\n'] = 8;
 
  _wordchars['t'] |= 16;
  _wordchars['r'] |= 16;
  _wordchars['n'] |= 16;
  _wordchars['f'] |= 16;
  _wordchars['0'] |= 16;
  _wordchars['"'] |= 16;
  _wordchars['\''] |= 16;
  _wordchars['\\'] |= 16;
  _wordchars['/'] |= 16;
 
  string[] a = { "jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec" };
  string[] b = { "mon", "tue", "wed", "thu", "fri", "sat", "sun" };
  _datetimewords = new sbyte[23, 21, 25];
 
  for (sbyte i = 0; i < a.length; i++)
  {
    var d = a[i];
    _datetimewords[d[0] - 97, d[1] - 97, d[2] - 97] = (sbyte)(i + 1);
  }
 
  for (sbyte i = 0; i < b.length; i++)
  {
    var d = b[i];
    _datetimewords[d[0] - 97, d[1] - 97, d[2] - 97] = (sbyte)-(i + 1);
  }
  _datetimewords['g' - 97, 'm' - 97, 't' - 97] = sbyte.maxvalue;
}
 
摘取部分blqw.json的代码

结束了…还要后续吗?…貌似我又要懒一段时间

我写的文章,除了纯代码,其他的都是想表达一种思想,一种解决方案.希望各位看官不要局限于文章中的现成的代码,要多关注整个文章的主题思路,谢谢!