轉載一個別人的文章
隔了很久沒寫東西了,主要是最近比較忙,更主要的是最近比較懶……
其實這篇很早就想寫了
工作和生活中經常可以看到一些程序猿,寫代碼的時候只關注代碼的邏輯性,而不考慮運行效率
其實這對大多數程序猿來說都是沒有問題的
不過作為一只有理想的CodeMonkey,我還是希望給大家分享一些性能優化心得
曾經在網上聽過這樣一句話
程序的可讀性和性能是成反比的
我非常贊同這句話,所以對於那些極度影響閱讀的性能優化我就不在這里贅述了
今天主要說的就是一些舉手之勞即可完成的性能優化
減少重復代碼
這是最基本的優化方案,盡可能減少那些重復做的事,讓他們只做一次
比較常見是這種代碼,同樣的Math.Cos(angle) 和Math.Sin(angle)都做了2次
|
1
2
3
4
5
6
7
8
|
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;
}
|
優化后
|
1
2
3
4
5
6
7
8
9
10
|
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;
}
|
還有另一種 ,在方法中實例化一個對象, 但是這個對象其實是可以復用的
|
1
2
3
4
5
|
public static string ConvertQuot(string html)
{
Regex regex = new Regex("&(quot|#34);", RegexOptions.IgnoreCase);
return regex.Replace(html, "\"");
}
|
優化后
|
1
2
3
4
5
|
readonly static Regex ReplaceQuot = new Regex("&(quot|#34);", RegexOptions.IgnoreCase | RegexOptions.Compiled);
public static string ConvertQuot(string html)
{
return ReplaceQuot.Replace(html, "\"");
}
|
還有一種是不必要的初始化,比如調用out參數之前,是不需要初始化的
|
1
2
3
4
5
6
7
8
9
|
public bool Check(int userid)
{
var user = new User();
if(GetUser(userid,out user))
{
return user.Level > 1;
}
return false;
}
|
這里的new User()就是不必要的操作,
優化后
|
1
2
3
4
5
6
7
8
9
|
public bool Check(int userid)
{
User user;
if(GetUser(userid,out user))
{
return user.Level > 1;
}
return false;
}
|
不要迷信正則表達式
正好在第一個栗子里說到了正在表達式(Regex)對象就順便一起說了
很多人以為正則表達式很快,非常快,超級的快
雖然正則表達式是挺快的,不過千萬不要迷信他,不信你看下面的栗子
|
1
2
3
4
5
6
7
8
9
10
11
12
|
//方法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
2
3
4
5
6
7
8
9
10
11
12
|
//方法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
最后給你們看一個真實的,杯具的栗子
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
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);
|
合理使用正則表達式
上面說了正則表達式的效率不高,並不是說就不要用他了,至少正則表達式的作用不僅僅如此而已
如果一定要用正則表達式的話也需要注意,能靜態全局公用的盡量全局公用
|
1
|
readonly static Regex regex = new Regex("[1234567890]", RegexOptions.Compiled);
|
注意他的第二個參數RegexOptions.Compiled 注釋是 指定將正則表達式編譯為程序集。這會產生更快的執行速度，但會增加啟動時間。
通俗的說就是加了這個枚舉,會使得初始化Regex對象變慢,但是執行字符串查找的時候更快, 不使用的話,初始化很多,查詢比較慢
之前測過相差蠻大的 ,代碼就不比較了,有興趣的可以自己試試相差多少
另外還有一些枚舉項,不確定是否對性能有影響,不過還是按規則使用會比較好
- RegexOptions.IgnoreCase // 指定不區分大小寫的匹配, 如果表達式中沒有字母,則不需要設定
- RegexOptions.Multiline // 多行模式。更改 ^ 和 $ 的含義…. 如果表達式中沒有^和$,則不需要設定
- RegexOptions.Singleline // 指定單行模式。更改點 (.) 的含義…. 如果表達式中沒有.,則不需要設定
讓編譯器預處理常量的計算
編譯器在編譯程序段的時候 如果發現有一些運算是常量對常量的,那么他會在編譯期間就計算完成,這樣可以使程序在執行時不用重復計算了
比如
不過編譯器有的時候也不是那么聰明的
這個時候就需要我們幫助一下了
給他加一個括號,讓他知道應該先計算常量,這樣就可以在編譯期間進行運算了
字符串比較
這個可能很多人知道了,但還是提一下
|
1
2
3
4
5
6
|
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),不要告訴我只有我一個人這么干)
另一種經常遇到的字符串拼接
|
1
2
3
4
5
6
7
8
9
10
11
12
|
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輔助,這種方案代碼少,但是性能相對差一些
|
1
2
3
4
|
public string JoinIds(List<User> users)
{
return "'" + string.Join("','", users.Select(it => it.Id)) + "'";
}
|
對於非3.5或對性能要求極高的場合
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
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
2
3
4
5
6
7
8
9
10
11
12
13
|
//寫法1
if(state == 1)
{
return true;
}
else
{
return false;
}
//寫法2
return state == 1 ? true : false;
//優化后
return state == 1;
|
類型的判斷
一般類型的判斷有2種形式
1,這種屬於代碼比較好寫,但是性能比較低, 原因就是GetType()的時候消耗了很多時間
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
Type type = obj.GetType();
switch (type.Name)
{
case "Int32":
break;
case "String":
break;
case "Boolean":
break;
case "DateTime":
break;
...
...
default:
break;
}
|
2,這種屬性寫代碼麻煩,但是性能很高的類型
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
if (obj is string)
{
}
else if (obj is int)
{
}
else if (obj is DateTime)
{
}
...
...
else
{
}
|
其實有個中間之道,既可以保證性能又可以比較好寫
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
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個
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
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");
}
}
|
優化后
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
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的值然后做進一步的操作
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
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長度
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
|
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的代碼
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
|
/// <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的代碼
|
結束了…還要后續嗎?…貌似我又要懶一段時間
我寫的文章,除了純代碼,其他的都是想表達一種思想,一種解決方案.希望各位看官不要局限於文章中的現成的代碼,要多關注整個文章的主題思路,謝謝!