自拍偷在线精品自拍偷,亚洲欧美中文日韩v在线观看不卡

C#中那些“舉手之勞”的性能優(yōu)化

作者：冰麟輕武
開發(fā) 后端
經(jīng)在網(wǎng)上聽過這樣一句話，程序的可讀性和性能是成反比的。我非常贊同這句話,所以對于那些極度影響閱讀的性能優(yōu)化我就不在這里贅述了，今天主要說的就是一些舉手之勞即可完成的性能優(yōu)化。

隔了很久沒寫東西了,主要是最近比較忙,更主要的是最近比較懶......其實(shí)這篇很早就像寫了。

工作和生活中經(jīng)?？梢钥吹揭恍┏绦蛟?寫代碼的時(shí)候只關(guān)注代碼的邏輯性,而不考慮運(yùn)行效率，其實(shí)這對大多數(shù)程序猿來說都是沒有問題的。

不過作為一只有理想的CodeMonkey,我還是希望給大家分享一些性能優(yōu)化心得

曾經(jīng)在網(wǎng)上聽過這樣一句話，程序的可讀性和性能是成反比的。我非常贊同這句話,所以對于那些極度影響閱讀的性能優(yōu)化我就不在這里贅述了，今天主要說的就是一些舉手之勞即可完成的性能優(yōu)化。

減少重復(fù)代碼

這是最基本的優(yōu)化方案,盡可能減少那些重復(fù)做的事,讓他們只做一次，比較常見是這種代碼,同樣的Math.Cos(angle) 和Math.Sin(angle)都做了2次。

  1. private Point RotatePt(double angle, Point pt)  
  2. {  
  3.      Point pRet = new Point();  
  4.      angle = -angle;  
  5.      pRet.X = (int)((double)pt.X * Math.Cos(angle) - (double)pt.Y * Math.Sin(angle));  
  6.      pRet.Y = (int)((double)pt.X * Math.Sin(angle) + (double)pt.Y * Math.Cos(angle));  
  7.      return pRet;  
  8. } 

優(yōu)化后

  1. private Point RotatePt3(double angle, Point pt)  
  2. {  
  3.     Point pRet = new Point();  
  4.     angle = -angle;  
  5.     double SIN_ANGLE = Math.Sin(angle);  
  6.     double COS_ANGLE = Math.Cos(angle);  
  7.     pRet.X =(int)(pt.X * COS_ANGLE - pt.Y * SIN_ANGLE);  
  8.     pRet.Y = (int)(pt.X * SIN_ANGLE + pt.Y * COS_ANGLE);  
  9.     return pRet;  
  10. } 

還有另一種 ,在方法中實(shí)例化一個(gè)對象, 但是這個(gè)對象其實(shí)是可以復(fù)用的。

  1. public static string ConvertQuot(string html)  
  2. {  
  3.     Regex regex = new Regex("&(quot|#34);", RegexOptions.IgnoreCase);  
  4.     return regex.Replace(html, "\"");  
  5. } 

優(yōu)化后

  1. readonly static Regex ReplaceQuot = new Regex("&(quot|#34);", RegexOptions.IgnoreCase | RegexOptions.Compiled);  
  2. public static string ConvertQuot(string html)  
  3. {  
  4.     return ReplaceQuot.Replace(html, "\"");  
  5. } 

還有一種是不必要的初始化,比如調(diào)用out參數(shù)之前,是不需要初始化的。

  1. public bool Check(int userid)  
  2. {  
  3.     var user = new User();  
  4.     if(GetUser(userid,out user))  
  5.     {  
  6.         return user.Level > 1;  
  7.     }  
  8.     return false;  
  9. } 

這里的new User()就是不必要的操作，

優(yōu)化后

  1. public bool Check(int userid)  
  2. {  
  3.     User user;  
  4.     if(GetUser(userid,out user))  
  5.     {  
  6.         return user.Level > 1;  
  7.     }  
  8.     return false;  
  9. } 

不要迷信正則表達(dá)式

正好在***個(gè)栗子里說到了正在表達(dá)式(Regex)對象就順便一起說了。

很多人以為正則表達(dá)式很快,非?？?超級(jí)的快。

雖然正則表達(dá)式是挺快的,不過千萬不要迷信他,不信你看下面的栗子。

  1. //方法1  
  2. public static string ConvertQuot1(string html)  
  3. {  
  4.     return html.Replace(""", "\"").Replace(""", "\"");  
  5. }  
  6.  
  7. readonly static Regex ReplaceQuot = new Regex("&(quot|#34);", RegexOptions.IgnoreCase | RegexOptions.Compiled);  
  8. //方法2  
  9. public static string ConvertQuot2(string html)  
  10. {  
  11.     return ReplaceQuot.Replace(html, "\"");  
  12. } 

有多少人認(rèn)為正則表達(dá)式比較快的,舉個(gè)手??

結(jié)果為10w次循環(huán)的時(shí)間 ,即使是10個(gè)Replace連用,也比Regex好,所以不要迷信他。

  1. //方法1  
  2. public static string ConvertQuot1(string html)  
  3. {  
  4.     return html.Replace("0", "").Replace("1", "").Replace("2", "").Replace("3", "").Replace("4", "").Replace("5", "").Replace("6", "").Replace("7", "").Replace("8", "").Replace("9", "");  
  5. }  
  6.  
  7. readonly static Regex ReplaceQuot = new Regex("[1234567890]", RegexOptions.IgnoreCase | RegexOptions.Compiled);  
  8. //方法2  
  9. public static string ConvertQuot2(string html)  
  10. {  
  11.     return ReplaceQuot.Replace(html, "");  
  12. } 

ConvertQuot1:3518

ConvertQuot2:12479

***給你們看一個(gè)真實(shí)的,杯具的栗子。

  1. Htmlstring = Regex.Replace(Htmlstring, @"<(.[^>]*)>", "", RegexOptions.IgnoreCase);  
  2. Htmlstring = Regex.Replace(Htmlstring, @"([\r\n])[\s]+", "", RegexOptions.IgnoreCase);  
  3. Htmlstring = Regex.Replace(Htmlstring, @"-->", "", RegexOptions.IgnoreCase);  
  4. Htmlstring = Regex.Replace(Htmlstring, @"<!--.*", "", RegexOptions.IgnoreCase);  
  5.  
  6. Htmlstring = Regex.Replace(Htmlstring, @"&(quot|#34);", "\"", RegexOptions.IgnoreCase);  
  7. Htmlstring = Regex.Replace(Htmlstring, @"&(amp|#38);", "&", RegexOptions.IgnoreCase);  
  8. Htmlstring = Regex.Replace(Htmlstring, @"&(lt|#60);", "<", RegexOptions.IgnoreCase);  
  9. Htmlstring = Regex.Replace(Htmlstring, @"&(gt|#62);", ">", RegexOptions.IgnoreCase);  
  10. Htmlstring = Regex.Replace(Htmlstring, @"&(nbsp|#160);", " ", RegexOptions.IgnoreCase);  
  11. Htmlstring = Regex.Replace(Htmlstring, @"&(iexcl|#161);", "\xa1", RegexOptions.IgnoreCase);  
  12. Htmlstring = Regex.Replace(Htmlstring, @"&(cent|#162);", "\xa2", RegexOptions.IgnoreCase);  
  13. Htmlstring = Regex.Replace(Htmlstring, @"&(pound|#163);", "\xa3", RegexOptions.IgnoreCase);  
  14. Htmlstring = Regex.Replace(Htmlstring, @"&(copy|#169);", "\xa9", RegexOptions.IgnoreCase);  
  15. Htmlstring = Regex.Replace(Htmlstring, @"&#(\d+);", "", RegexOptions.IgnoreCase); 

#p#

合理使用正則表達(dá)式

上面說了正則表達(dá)式的效率不高,并不是說就不要用他了,至少正則表達(dá)式的作用不僅僅如此而已。

如果一定要用正則表達(dá)式的話也需要注意,能靜態(tài)全局公用的盡量全局公用。

  1. readonly static Regex regex = new Regex("[1234567890]", RegexOptions.Compiled); 

意他的第二個(gè)參數(shù)RegexOptions.Compiled 注釋是 指定將正則表達(dá)式編譯為程序集。這會(huì)產(chǎn)生更快的執(zhí)行速度，但會(huì)增加啟動(dòng)時(shí)間。

通俗的說就是加了這個(gè)枚舉,會(huì)使得初始化Regex對象變慢,但是執(zhí)行字符串查找的時(shí)候更快, 不使用的話,初始化很多,查詢比較慢。

之前測過相差蠻大的 ,代碼就不比較了,有興趣的可以自己試試相差多少。

另外還有一些枚舉項(xiàng),不確定是否對性能有影響,不過還是按規(guī)則使用會(huì)比較好。

  • RegexOptions.IgnoreCase // 指定不區(qū)分大小寫的匹配, 如果表達(dá)式中沒有字母,則不需要設(shè)定
  • RegexOptions.Multiline // 多行模式。更改 ^ 和 $ 的含義.... 如果表達(dá)式中沒有^和$,則不需要設(shè)定
  • RegexOptions.Singleline // 指定單行模式。更改點(diǎn) (.) 的含義.... 如果表達(dá)式中沒有.,則不需要設(shè)定

讓編譯器預(yù)處理常量的計(jì)算

編譯器在編譯程序段的時(shí)候 如果發(fā)現(xiàn)有一些運(yùn)算是常量對常量的,那么他會(huì)在編譯期間就計(jì)算完成,這樣可以使程序在執(zhí)行時(shí)不用重復(fù)計(jì)算了。

比如

不過編譯器有的時(shí)候也不是那么聰明的，

這個(gè)時(shí)候就需要我們幫助一下了，

給他加一個(gè)括號(hào),讓他知道應(yīng)該先計(jì)算常量,這樣就可以在編譯期間進(jìn)行運(yùn)算了。

字符串比較

這個(gè)可能很多人知道了,但還是提一下。

  1. string s = "";  
  2. 1) if(s == ""){}  
  3. 2) if(s == string.Empty){}  
  4. 3) if (string.IsNullOrEmpty(s)) { }  
  5. 4) if(s != null && s.Length ==0) {}   
  6. 5) if((s+"").Length == 0){} 

1,2最慢 3較快 4,5最快

1,2幾乎沒區(qū)別 4,5幾乎沒區(qū)別，不過這個(gè)只適用于比較null和空字符串,如果是連續(xù)的空白就是string.IsNullOrWhiteSpace最快了,不過這個(gè)方法2.0里面沒有。

所以2.0可以這樣 (s+"").trim() == 0

這里的關(guān)鍵就是 s + "" 這個(gè)操作可以把null轉(zhuǎn)換為""

注意第二個(gè)參數(shù)只能是""或string.Empty 這樣的累加幾乎是不消耗時(shí)間的,如果第二個(gè)參數(shù)是" "(一個(gè)空格)這個(gè)時(shí)間就遠(yuǎn)遠(yuǎn)不止了。

字符串拼接

字符串累加,這個(gè)道理和Regex一樣,不要盲目崇拜StringBuilder，在大量(或不確定的)string拼接的時(shí)候,StringBuilder確實(shí)可以起到提速的作用，而少數(shù)幾個(gè)固定的string累加的時(shí)候就不需要StringBuilder 了,畢竟StringBuilder 的初始化也是需要時(shí)間的。

ps: 這段我確實(shí)記得我是寫過的來著,不知道怎么的,發(fā)出來的時(shí)候就不見了.....

此外還有一個(gè)string.Concat方法,該方法可以小幅度的優(yōu)化程序的速度,幅度很小。

他和string.Join的區(qū)別在于沒有間隔符號(hào)(我之前常用string.Join("",a,b,c,d),不要告訴我只有我一個(gè)人這么干)

另一種經(jīng)常遇到的字符串拼接

  1. public string JoinIds(List<User> users)  
  2. {  
  3.     StringBuilder sb = new StringBuilder();  
  4.     foreach (var user in users)  
  5.     {  
  6.         sb.Append("'");  
  7.         sb.Append(user.Id);  
  8.         sb.Append("',");  
  9.     }  
  10.     sb.Length = sb.Length - 1;  
  11.     return sb.ToString();  
  12. } 

對于這種情況有2中優(yōu)化的方案

對于3.5以上可以直接使用Linq輔助,這種方案代碼少,但是性能相對差一些

  1. public string JoinIds(List<User> users)  
  2. {  
  3.     return "'" + string.Join("','", users.Select(it => it.Id)) + "'";  
  4. } 

對于非3.5或?qū)π阅芤髽O高的場合

  1. public string JoinIds(List<User> users)  
  2. {  
  3.     var ee = users.GetEnumerator();  
  4.     StringBuilder sb = new StringBuilder();  
  5.     if (ee.MoveNext())  
  6.     {  
  7.         sb.Append("'");  
  8.         sb.Append(ee.Current.Id);  
  9.         sb.Append("'");  
  10.         while (ee.MoveNext())  
  11.         {  
  12.             sb.Append(",'");  
  13.             sb.Append(ee.Current.Id);  
  14.             sb.Append("'");  
  15.         }  
  16.     }  
  17.     return sb.ToString();  
  18. } 

#p#

bool類型的判斷返回

這種現(xiàn)象常見于新手程序員中

  1. //寫法1  
  2. if(state == 1)  
  3. {  
  4.     return true;  
  5. }  
  6. else 
  7. {  
  8.     return false;  
  9. }  
  10. //寫法2  
  11. return state == 1 ? true : false;  
  12. //優(yōu)化后  
  13. return state == 1; 

類型的判斷

一般類型的判斷有2種形式

1,這種屬于代碼比較好寫,但是性能比較低, 原因就是GetType()的時(shí)候消耗了很多時(shí)間。

  1. Type type = obj.GetType();  
  2. switch (type.Name)  
  3. {  
  4.     case "Int32":  
  5.         break;  
  6.     case "String":  
  7.         break;  
  8.     case "Boolean":  
  9.         break;  
  10.     case "DateTime":  
  11.         break;  
  12.     ...  
  13.     ...  
  14.     default:  
  15.         break;  
  16. } 

2,這種屬性寫代碼麻煩,但是性能很高的類型。

  1. if (obj is string)  
  2. {  
  3.  
  4. }  
  5. else if (obj is int)  
  6. {  
  7.  
  8. }  
  9. else if (obj is DateTime)  
  10. {  
  11.  
  12. }  
  13. ...  
  14. ...  
  15. else 
  16. {  
  17.  
  18. } 

其實(shí)有個(gè)中間之道,既可以保證性能又可以比較好寫

  1. IConvertible conv = obj as IConvertible;  
  2. if (conv != null)  
  3. {  
  4.     switch (conv.GetTypeCode())  
  5.     {  
  6.         case TypeCode.Boolean:  
  7.             break;  
  8.         case TypeCode.Byte:  
  9.             break;  
  10.         case TypeCode.Char:  
  11.             break;  
  12.         case TypeCode.DBNull:  
  13.             break;  
  14.         case TypeCode.DateTime:  
  15.             break;  
  16.         case TypeCode.Decimal:  
  17.             break;  
  18.         case TypeCode.Double:  
  19.             break;  
  20.         case TypeCode.Empty:  
  21.             break;  
  22.         case TypeCode.Int16:  
  23.             break;  
  24.         case TypeCode.Int32:  
  25.             break;  
  26.         ...  
  27.         ...  
  28.         default:  
  29.             break;  
  30.     }  
  31. }  
  32. else 
  33. {  
  34.     //處理其他類型  
  35. } 

大部分情況下 這個(gè)是可以用的 如果你自己有個(gè)類型實(shí)現(xiàn)了IConvertible,然后返回TypeCode.Int32 就不再這個(gè)討論范圍之內(nèi)了。

使用枚舉作為索引

下面這個(gè)是一個(gè)真實(shí)的例子,為了突出重點(diǎn),做了部分修改,刪除了多余的分支,源代碼中不只4個(gè)。

  1. enum TemplateCode  
  2. {  
  3.     None = 0,  
  4.     Head = 1,  
  5.     Menu = 2,  
  6.     Foot = 3,  
  7.     Welcome = 4,  
  8. }  
  9.  
  10. public string GetHtml(TemplateCode tc)  
  11. {  
  12.     switch (tc)  
  13.     {  
  14.         case TemplateCode.Head:  
  15.             return GetHead();  
  16.         case TemplateCode.Menu:  
  17.             return GetMenu();  
  18.         case TemplateCode.Foot:  
  19.             return GetFoot();  
  20.         case TemplateCode.Welcome:  
  21.             return GetWelcome();  
  22.         default:  
  23.             throw new ArgumentOutOfRangeException("tc");  
  24.     }  
  25. } 

優(yōu)化后

  1. readonly static Func<string>[] GetTemplate = InitTemplateFunction();  
  2.  
  3. private static Func<string>[] InitTemplateFunction()  
  4. {  
  5.     var arr = new Func<string>[5];  
  6.     arr[1] = GetHead;  
  7.     arr[2] = GetMenu;  
  8.     arr[3] = GetFoot;  
  9.     arr[4] = GetWelcome;  
  10.     return arr;  
  11. }   
  12.  
  13. public string GetHtml(TemplateCode tc)  
  14. {  
  15.     var index = (int)tc;  
  16.     if (index >= 1 && index <= 4)  
  17.     {  
  18.         return GetTemplate[index]();  
  19.     }  
  20.     throw new ArgumentOutOfRangeException("tc");  
  21. } 

不過有的時(shí)候,枚舉不一定都是連續(xù)的數(shù)字,那么也可以使用Dictionary。

  1. readonly static Dictionary<TemplateCode, Func<string>> TemplateDict = InitTemplateFunction();  
  2.  
  3. private static Dictionary<TemplateCode, Func<string>> InitTemplateFunction()  
  4. {  
  5.     var ditc = new Dictionary<TemplateCode, Func<string>>();  
  6.     ditc.Add(TemplateCode.Head, GetHead);  
  7.     ditc.Add(TemplateCode.Menu, GetMenu);  
  8.     ditc.Add(TemplateCode.Foot, GetFoot);  
  9.     ditc.Add(TemplateCode.Welcome, GetWelcome);  
  10.     return ditc;  
  11. }   
  12.  
  13. public string GetHtml(TemplateCode tc)  
  14. {  
  15.     Func<string> func;  
  16.     if (TemplateDict.TryGetValue(tc,out func))  
  17.     {  
  18.         return func();  
  19.     }  
  20.     throw new ArgumentOutOfRangeException("tc");  
  21. } 

這種優(yōu)化在分支比較多的時(shí)候很好用,少的時(shí)候作用有限。

#p#

字符類型Char,分支判斷時(shí)的處理技巧

這部分內(nèi)容比較復(fù)雜,而且適用范圍有限,如果平時(shí)用不到的就可以忽略了。

在處理字符串對象的時(shí)候,有時(shí)會(huì)需要判斷char的值然后做進(jìn)一步的操作。

  1. public string Show(char c)  
  2. {  
  3.     if (c >= '0' && c <= '9')  
  4.     {  
  5.         return "數(shù)字";  
  6.     }  
  7.     else if (c >= 'a' && c <= 'z')  
  8.     {  
  9.         return "小寫字母";  
  10.     }  
  11.     else if (c >= 'A' && c <= 'Z')  
  12.     {  
  13.         return "大寫字母";  
  14.     }  
  15.     else if (c == '/' || c == '\\' || c == '|'  
  16.         || c == '$' || c == '#' || c == '+' 
  17.         || c == '%' || c == '&' || c == '-' 
  18.         || c == '^' || c == '*' || c == '=')  
  19.     {  
  20.         return "特殊符號(hào)";  
  21.     }  
  22.     else if (c == ',' || c == '.' || c == '!' 
  23.         || c == ':' || c == ';' || c == '?' 
  24.         || c == '"' || c == '\'')  
  25.     {  
  26.         return "標(biāo)點(diǎn)符號(hào)";  
  27.     }  
  28.     else 
  29.     {  
  30.         return "其他";  
  31.     }  
  32. } 

這里有一種空間換時(shí)間的優(yōu)化方式, 雖說是空間換時(shí)間,但是實(shí)際浪費(fèi)的空間不會(huì)很多,因?yàn)閏har最多只有65536長度。

  1. readonly static byte[] CharMap = InitCharMap();  
  2.  
  3. private static byte[] InitCharMap()  
  4. {  
  5.     var arr = new byte[char.MaxValue];  
  6.     for (char i = '0'; i <= '9'; i++)  
  7.     {  
  8.         arr[i] = 1;  
  9.     }  
  10.     for (char i = 'a'; i <= 'z'; i++)  
  11.     {  
  12.         arr[i] = 2;  
  13.     }  
  14.     for (char i = 'A'; i <= 'Z'; i++)  
  15.     {  
  16.         arr[i] = 3;  
  17.     }  
  18.     arr['/'] = 4;  
  19.     arr['\\'] = 4;  
  20.     arr['|'] = 4;  
  21.     arr['$'] = 4;  
  22.     arr['#'] = 4;  
  23.     arr['+'] = 4;  
  24.     arr['%'] = 4;  
  25.     arr['&'] = 4;  
  26.     arr['-'] = 4;  
  27.     arr['^'] = 4;  
  28.     arr['*'] = 4;  
  29.     arr['='] = 4;  
  30.  
  31.     arr[','] = 5;  
  32.     arr['.'] = 5;  
  33.     arr['!'] = 5;  
  34.     arr[':'] = 5;  
  35.     arr[';'] = 5;  
  36.     arr['?'] = 5;  
  37.     arr['"'] = 5;  
  38.     arr['\''] = 5;  
  39.     return arr;  
  40. }  
  41.  
  42. public string Show(char c)  
  43. {  
  44.     switch (CharMap[c])  
  45.     {  
  46.         case 0:  
  47.             return "其他";  
  48.         case 1:  
  49.             return "數(shù)字";  
  50.         case 2:  
  51.             return "小寫字母";  
  52.         case 3:  
  53.             return "大寫字母";  
  54.         case 4:  
  55.             return "特殊符號(hào)";  
  56.         case 5:  
  57.             return "標(biāo)點(diǎn)符號(hào)";  
  58.         default:  
  59.             return "其他";  
  60.     }  
  61. } 

原先僅特殊符號(hào)一部分就需要判斷12次,修改過后只判斷一次就可以得到結(jié)果了，

這方面的栗子在我的Json組件(代碼)(文章1,2,3)中也有使用。

  1. /// <summary>  
  2. /// <para>包含1: 可以為頭的字符</para>  
  3. /// <para>包含2: 可以為單詞的字符</para>  
  4. /// <para>包含4: 可以為數(shù)字的字符</para>  
  5. /// <para>等于8: 空白字符</para>  
  6. /// <para>包含16:轉(zhuǎn)義字符</para>  
  7. /// <para></para>  
  8. /// </summary>  
  9. private readonly static byte[] _WordChars = new byte[char.MaxValue];  
  10. private readonly static sbyte[] _UnicodeFlags = new sbyte[123];  
  11. private readonly static sbyte[, ,] _DateTimeWords;  
  12. static UnsafeJsonReader()  
  13. {  
  14.     for (int i = 0; i < 123; i++)  
  15.     {  
  16.         _UnicodeFlags[i] = -1;  
  17.     }  
  18.  
  19.     _WordChars['-'] = 1 | 4;  
  20.     _WordChars['+'] = 1 | 4;  
  21.  
  22.     _WordChars['$'] = 1 | 2;  
  23.     _WordChars['_'] = 1 | 2;  
  24.     for (char c = 'a'; c <= 'z'; c++)  
  25.     {  
  26.         _WordChars[c] = 1 | 2;  
  27.         _UnicodeFlags[c] = (sbyte)(c - 'a' + 10);  
  28.     }  
  29.     for (char c = 'A'; c <= 'Z'; c++)  
  30.     {  
  31.         _WordChars[c] = 1 | 2;  
  32.         _UnicodeFlags[c] = (sbyte)(c - 'A' + 10);  
  33.     }  
  34.  
  35.     _WordChars['.'] = 1 | 2 | 4;  
  36.     for (char c = '0'; c <= '9'; c++)  
  37.     {  
  38.         _WordChars[c] = 4;  
  39.         _UnicodeFlags[c] = (sbyte)(c - '0');  
  40.     }  
  41.  
  42.     //科學(xué)計(jì)數(shù)法  
  43.     _WordChars['e'] |= 4;  
  44.     _WordChars['E'] |= 4;  
  45.  
  46.     _WordChars[' '] = 8;  
  47.     _WordChars['\t'] = 8;  
  48.     _WordChars['\r'] = 8;  
  49.     _WordChars['\n'] = 8;  
  50.  
  51.  
  52.     _WordChars['t'] |= 16;  
  53.     _WordChars['r'] |= 16;  
  54.     _WordChars['n'] |= 16;  
  55.     _WordChars['f'] |= 16;  
  56.     _WordChars['0'] |= 16;  
  57.     _WordChars['"'] |= 16;  
  58.     _WordChars['\''] |= 16;  
  59.     _WordChars['\\'] |= 16;  
  60.     _WordChars['/'] |= 16;  
  61.  
  62.  
  63.     string[] a =  { "jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec" };  
  64.     string[] b =  { "mon", "tue", "wed", "thu", "fri", "sat", "sun" };  
  65.     _DateTimeWords = new sbyte[23, 21, 25];  
  66.  
  67.     for (sbyte i = 0; i < a.Length; i++)  
  68.     {  
  69.         var d = a[i];  
  70.         _DateTimeWords[d[0] - 97, d[1] - 97, d[2] - 97] = (sbyte)(i + 1);  
  71.     }  
  72.  
  73.     for (sbyte i = 0; i < b.Length; i++)  
  74.     {  
  75.         var d = b[i];  
  76.         _DateTimeWords[d[0] - 97, d[1] - 97, d[2] - 97] = (sbyte)-(i + 1);  
  77.     }  
  78.     _DateTimeWords['g' - 97, 'm' - 97, 't' - 97] = sbyte.MaxValue;  
  79. }  
  80.  
  81. 摘取部分blqw.Json的代碼 

原文鏈接：http://www.cnblogs.com/blqw/p/3619132.html

責(zé)任編輯：林師授 來源： 博客園
C#優(yōu)化性能優(yōu)化
相關(guān)推薦

2015-09-08 14:42:17

Android性能優(yōu)化

2024-10-07 08:37:32

線程池C#管理機(jī)制

2024-09-12 17:23:02

2022-04-08 09:47:55

性能優(yōu)化開發(fā)

2022-04-13 10:03:59

性能優(yōu)化性能分析工具JVM

2022-02-18 19:24:15

性能優(yōu)化代碼

2011-05-03 17:51:47

針式打印機(jī)

2024-05-10 08:44:53

C#軟件開發(fā)優(yōu)化代碼

2009-08-28 17:18:55

foreach循環(huán)

2009-12-16 11:16:30

2025-03-27 03:20:00

C#開發(fā)字符串

2021-06-10 09:40:12

C++性能優(yōu)化Linux

2024-11-25 15:00:00

C#定時(shí)任務(wù)開發(fā)

2010-10-19 10:03:02

Lambda表達(dá)式

2014-04-17 10:37:43

C++.NET Native

2021-07-14 11:13:46

線程性能優(yōu)化阿里云

2010-04-09 15:08:17

Oracle 數(shù)據(jù)庫性

2015-06-05 13:45:17

C#新手易犯

2009-08-12 15:24:00

C#測量cpu性能

2009-09-02 16:21:20

C#字符串
點(diǎn)贊
收藏

51CTO技術(shù)棧公眾號(hào)