曾经在网上听过这样一句话
程序的可读性和性能是成反比的
我非常赞同这句话,所以对于那些极度影响阅读的性能优化我就不在这里赘述了
今天主要说的就是一些举手之劳即可完成的性能优化
减少重复代码
这是最基本的优化方案,尽可能减少那些重复做的事,让他们只做一次
比较常见是这种代码,同样的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测试数据piled);
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测试数据piled);
//方法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测试数据piled);
//方法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测试数据piled);
注意他的第二个参数regexoptions测试数据piled 注释是 指定将正则表达式编译为程序集。这会产生更快的执行速度，但会增加启动时间。
通俗的说就是加了这个枚举,会使得初始化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的代码
结束了…还要后续吗?…貌似我又要懒一段时间
我写的文章,除了纯代码,其他的都是想表达一种思想,一种解决方案.希望各位看官不要局限于文章中的现成的代码,要多关注整个文章的主题思路,谢谢!
原文链接：http://HdhCmsTestcnblogs测试数据/taiyonghai/p/5695666.html
dy("nrwz");
查看更多关于C#程序员应该养成的程序性能优化写法的详细内容...