隔了很久没写东西了,主要是最近比较忙,更主要的是最近比较懒......

其实这篇很早就想写了

工作和生活中经常可以看到一些程序猿,写代码的时候只关注代码的逻辑性,而不考虑运行效率

其实这对大多数程序猿来说都是没有问题的

不过作为一只有理想的CodeMonkey,我还是希望给大家分享一些性能优化心得

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

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

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

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

减少重复代码

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

比较常见是这种代码,同样的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 > ;
}
return false;
}

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

优化后

public bool Check(int userid)
{
User user;
if(GetUser(userid,out user))
{
return user.Level > ;
}
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("", "").Replace("", "").Replace("", "").Replace("", "").Replace("", "").Replace("", "").Replace("", "").Replace("", "").Replace("", "").Replace("", "");
} 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 = "";
) if(s == ""){}
) if(s == string.Empty){}
) if (string.IsNullOrEmpty(s)) { }
) if(s != null && s.Length ==) {}
) if((s+"").Length == ){}

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 的初始化也是需要时间的

感谢#5楼 2014-03-24 16:45 残蛹 博友提供的说明

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 - ;
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 == )
{
return true;
}
else
{
return false;
}
//写法2
return state == ? true : false;
//优化后
return state == ;

类型的判断

一般类型的判断有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 = ,
Head = ,
Menu = ,
Foot = ,
Welcome = ,
} 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>[];
arr[] = GetHead;
arr[] = GetMenu;
arr[] = GetFoot;
arr[] = GetWelcome;
return arr;
} public string GetHtml(TemplateCode tc)
{
var index = (int)tc;
if (index >= && index <= )
{
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 = ''; i <= ''; i++)
{
arr[i] = ;
}
for (char i = 'a'; i <= 'z'; i++)
{
arr[i] = ;
}
for (char i = 'A'; i <= 'Z'; i++)
{
arr[i] = ;
}
arr['/'] = ;
arr['\\'] = ;
arr['|'] = ;
arr['$'] = ;
arr['#'] = ;
arr['+'] = ;
arr['%'] = ;
arr['&'] = ;
arr['-'] = ;
arr['^'] = ;
arr['*'] = ;
arr['='] = ; arr[','] = ;
arr['.'] = ;
arr['!'] = ;
arr[':'] = ;
arr[';'] = ;
arr['?'] = ;
arr['"'] = ;
arr['\''] = ;
return arr;
} public string Show(char c)
{
switch (CharMap[c])
{
case :
return "其他";
case :
return "数字";
case :
return "小写字母";
case :
return "大写字母";
case :
return "特殊符号";
case :
return "标点符号";
default:
return "其他";
}
}

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

这方面的栗子在我的Json组件(代码)(文章1,2,3)中也有使用

/// <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[];
private readonly static sbyte[, ,] _DateTimeWords;
static UnsafeJsonReader()
{
for (int i = ; i < ; i++)
{
_UnicodeFlags[i] = -;
} _WordChars['-'] = | ;
_WordChars['+'] = | ; _WordChars['$'] = | ;
_WordChars['_'] = | ;
for (char c = 'a'; c <= 'z'; c++)
{
_WordChars[c] = | ;
_UnicodeFlags[c] = (sbyte)(c - 'a' + );
}
for (char c = 'A'; c <= 'Z'; c++)
{
_WordChars[c] = | ;
_UnicodeFlags[c] = (sbyte)(c - 'A' + );
} _WordChars['.'] = | | ;
for (char c = ''; c <= ''; c++)
{
_WordChars[c] = ;
_UnicodeFlags[c] = (sbyte)(c - '');
} //科学计数法
_WordChars['e'] |= ;
_WordChars['E'] |= ; _WordChars[' '] = ;
_WordChars['\t'] = ;
_WordChars['\r'] = ;
_WordChars['\n'] = ; _WordChars['t'] |= ;
_WordChars['r'] |= ;
_WordChars['n'] |= ;
_WordChars['f'] |= ;
_WordChars[''] |= ;
_WordChars['"'] |= ;
_WordChars['\''] |= ;
_WordChars['\\'] |= ;
_WordChars['/'] |= ; 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[, , ]; for (sbyte i = ; i < a.Length; i++)
{
var d = a[i];
_DateTimeWords[d[] - , d[] - , d[] - ] = (sbyte)(i + );
} for (sbyte i = ; i < b.Length; i++)
{
var d = b[i];
_DateTimeWords[d[] - , d[] - , d[] - ] = (sbyte)-(i + );
}
_DateTimeWords['g' - , 'm' - , 't' - ] = sbyte.MaxValue;
}

摘取部分blqw.Json的代码

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

C#中那些[举手之劳]的性能优化的更多相关文章

  1. 【转】PHP中被忽略的性能优化利器:生成器.md

      PHP  如果是做Python或者其他语言的小伙伴,对于生成器应该不陌生.但很多PHP开发者或许都不知道生成器这个功能,可能是因为生成器是PHP 5.5.0才引入的功能,也可以是生成器作用不是很明 ...

  2. Java开发中程序和代码性能优化

    现在计算机的处理性能越来越好,加上JDK升级对一些代码的优化,在代码层针对一些细节进行调整可能看不到性能的明显提升, 但是我觉得在开发中注意这些,更多的是可以保持一种性能优先的意识,对一些敲代码时间比 ...

  3. Android中数据库Sqlite的性能优化

    1.索引简单的说,索引就像书本的目录,目录可以快速找到所在页数,数据库中索引可以帮助快速找到数据,而不用全表扫描,合适的索引可以大大提高数据库查询的效率.(1). 优点大大加快了数据库检索的速度,包括 ...

  4. java开发代码中的50个性能优化细节

    在java程序中,性能的大部分原因并不在java与语言,而是程序本身.养成好的编码习惯非常重要,能够显著地提升程序性能. 1:尽量在合适的场合使用单例 使用单利可以减轻加载的负担,缩短加载时间,提高加 ...

  5. 一次项目实践中DBCP数据库连接池性能优化

    关于数据库连接池DBCP的关注源于刚刚结束的一轮测试,测试内容是衡量某Webserver服务创建用户接口的性能.这是一款典型的tomcat应用,使用的测试工具是Grinder.DBCP作为tomcat ...

  6. PHP中被忽略的性能优化利器:生成器

    如果是做Python或者其他语言的小伙伴,对于生成器应该不陌生.但很多PHP开发者或许都不知道生成器这个功能,可能是因为生成器是PHP 5.5.0才引入的功能,也可以是生成器作用不是很明显.但是,生成 ...

  7. PHP系列 | [转] PHP中被忽略的性能优化利器:生成器

    官方:https://www.php.net/manual/zh/language.generators.overview.php 原文:https://segmentfault.com/a/1190 ...

  8. EntityFramework之异步、事务及性能优化(九)

    前言 本文开始前我将循序渐进先了解下实现EF中的异步,并将重点主要是放在EF中的事务以及性能优化上,希望通过此文能够帮助到你. 异步 既然是异步我们就得知道我们知道在什么情况下需要使用异步编程,当等待 ...

  9. T- SQL性能优化详解

    摘自:http://www.cnblogs.com/Shaina/archive/2012/04/22/2464576.html 故事开篇:你和你的团队经过不懈努力,终于使网站成功上线,刚开始时,注册 ...

随机推荐

  1. Html Agility Pack 解析Html

    Hello 好久不见 哈哈,今天给大家分享一个解析Html的类库 Html Agility Pack.这个适用于想获取某网页里面的部分内容.今天就拿我的Csdn的博客列表来举例. 打开页面  用Fir ...

  2. 告别被拒,如何提升iOS审核通过率(上篇)

    iOS审核一直是每款移动产品上架苹果商店时面对的一座大山,每次提审都像是一次漫长而又悲壮的旅行,经常被苹果拒之门外,无比煎熬.那么问题来了,我们有没有什么办法准确把握苹果审核准则,从而提升审核的通过率 ...

  3. ASP.NET MVC5+EF6+EasyUI 后台管理系统(72)-微信公众平台开发-消息处理

    系列目录 前言 Senparc.Weixin.MP SDK提供了MessageHandler消息处理类 在作者的Wiki中也详细说明了如何定义这个类,下面我们来演示,消息的回复,及效果 了解Messa ...

  4. 简记用ArcGIS处理某项目需求中数据的步骤

    文章版权由作者李晓晖和博客园共有,若转载请于明显处标明出处:http://www.cnblogs.com/naaoveGIS/ 1. 背景 项目需求涉及如下几个步骤: a.矢量化 b.获取范围内要素 ...

  5. ThinkPHP+Smarty模板中截取包含中英文混合的字符串乱码的解决方案

    好几天没写博客了,其实有好多需要总结的,因为最近一直在忙着做项目,但是困惑了几天的Smarty模板中截取包含中英文混合的字符串乱码的问题,终于解决了,所以记录下来,需要的朋友看一下: 出现乱码的原因: ...

  6. addTwoNumbers

    大神的代码好短,自己写的120多行=_= 各种判断 ListNode *f(ListNode *l1, ListNode *l2) { ListNode *p1 = l1; ListNode *p2 ...

  7. Android开发案例 – 在AbsListView中使用倒计时

    在App中, 有多种多样的倒计时需求, 比如: 在单View上, 使用倒计时, 如(如图-1) 在ListView(或者GridView)的ItemView上, 使用倒计时(如图-2) 图-1 图-2 ...

  8. WebStorm 2016 最新版激活(activation code方式)

    WebStorm 2016 最新版激活(activation code方式) WebStorm activation code WebStorm 最新版本激活方式: 今天下载最新版本的WebStorm ...

  9. 分享一个MySQL分库分表备份脚本(原)

    分享一个MySQL分库备份脚本(原) 开发思路: 1.路径:规定备份到什么位置,把路径(先判断是否存在,不存在创建一个目录)先定义好,我的路径:/mysql/backup,每个备份用压缩提升效率,带上 ...

  10. 当我们在谈论kmeans(1)

    本稿为初稿,后续可能还会修改:如果转载,请务必保留源地址,非常感谢! 博客园:http://www.cnblogs.com/data-miner/ 简书:建设中... 知乎:建设中... 当我们在谈论 ...