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)对象就顺便一起说了

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

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

//方法1public static string ConvertQuot1(string HTML){  return HTML.Replace(""","\"").Replace(""","\"");} Readonly static Regex ReplaceQuot = new Regex("&(quot|#34);",RegexOptions.IgnoreCase | RegexOptions.Compiled);//方法2public static string ConvertQuot2(string HTML){  return ReplaceQuot.Replace(HTML,"\"");}

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

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

//方法1public 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]","");}

ConvertQuot1:3518
ConvertQuot2:12479

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

HTMLstring = Regex.Replace(HTMLstring,@"<(.[^>]*)>","",RegexOptions.IgnoreCase);HTMLstring = Regex.Replace(HTMLstring,@"([\r\n])[\s]+",@"-->",@"<!--.*",RegexOptions.IgnoreCase); HTMLstring = Regex.Replace(HTMLstring,@"&(quot|#34);","\"",@"&(amp|#38);","&",@"&(lt|#60);","<",@"&(gt|#62);",">",@"&(nbsp|#160);"," ",@"&(IExcl|#161);","\xa1",@"&(cent|#162);","\xa2",@"&(pound|#163);","\xa3",@"&(copy|#169);","\xa9",@"&#(\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类型的判断返回

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

//写法1if(state == 1){  return true;}else{  return false;}//写法2return 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组件(代码)(文章1,2,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[2] - 97] = (sbyte)-(i + 1);  }  _DateTimeWords['g' - 97,'m' - 97,'t' - 97] = sbyte.MaxValue;} 摘取部分blqw.Json的代码

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

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

总结

以上是内存溢出为你收集整理的C#程序员应该养成的程序性能优化写法全部内容，希望文章能够帮你解决C#程序员应该养成的程序性能优化写法所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。