隔了很久沒寫東西了,主要是最近比較忙,更主要的是最近比較懶……
其實這篇很早就想寫了
工作和生活中經常可以看到一些程式猿,寫程式碼的時候只關注程式碼的邏輯性,而不考慮執行效率
其實這對大多數程式猿來說都是沒有問題的
不過作為一隻有理想的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的程式碼 |
結束了…還要後續嗎?…貌似我又要懶一段時間
我寫的文章,除了純程式碼,其他的都是想表達一種思想,一種解決方案.希望各位看官不要侷限於文章中的現成的程式碼,要多關注整個文章的主題思路,謝謝!