C#的性能如何優化

這篇文章主要講解了“C#的性能如何優化”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“C#的性能如何優化”吧！

減少重復代碼

這是最基本的優化方案,盡可能減少那些重復做的事,讓他們只做一次，比較常見是這種代碼,同樣的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 > 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.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("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

***給你們看一個真實的,杯具的栗子。

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 = "";  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組件(代碼)(文章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[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的代碼

感謝各位的閱讀，以上就是“C#的性能如何優化”的內容了，經過本文的學習后，相信大家對C#的性能如何優化這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！