ASP.NET性能優化

一、傳回多個資料集

　　檢查你的通路資料庫的代碼，看是否存在着要傳回多次的請求。每次往返降低了你的應用程式的每秒能夠響應請求的次數。通過在單個資料庫請求中傳回多個結果集，可以減少與資料庫通信的時間，使你的系統具有擴充性，也可以減少資料庫伺服器響應請求的工作量。

　　如果用動态的SQL語句來傳回多個資料集，那用存儲過程來替代動态的SQL語句會更好些。是否把業務邏輯寫到存儲過程中，這個有點争議。但是我認為，把業務邏輯寫到存儲過程裡面可以限制傳回結果集的大小，減小網絡資料的流量，在邏輯層也不用在過濾資料，這是一個好事情。

　　用SqlCommand對象的ExecuteReader方法傳回一個強類型的業務對象，再調用NextResult方法來移動資料集指針來定位資料集。傳回多個ArrayList強類型對象。隻從資料庫中傳回你需要的資料可以大大的減小你的伺服器所耗用的記憶體。

二、對資料進行分頁

　　ASP.NET的DataGrid有一個非常有用的功能：分頁。如果DataGrid允許分頁，在某一時刻它隻下載下傳某一頁的資料，另外，它有一個資料分頁的濟覽導航欄，它讓你可以選擇浏覽某一頁，而且每次隻下載下傳一頁的資料。

　　但是它有一個小小的缺點，就是你必須把所有的資料都綁定到DataGrid中。也就是說，你的資料層必須傳回所有的資料，然後DataGrid再根據目前頁過濾出目前頁所需要的資料顯示出來。如果有一個一萬條記錄的結果集要用DataGrid進行分頁，假設DataGrid每頁隻顯示25條資料，那就意味着每次請求都有9975條資料都是要丢棄的。每次請求都要傳回這麼大的資料集，對應用程式的性能影響是非常大的。

　　一個好的解決方案是寫一個分頁的存儲過程，例如對Northwind資料庫orders表的分頁存儲過程。你隻需要傳目前頁碼，每頁顯示的條數兩個參數進來，存儲過程會傳回相應的結果。

　　在伺服器端，專門寫了一個分頁的控件來處理資料的分頁，在一個存儲過程裡面傳回了兩個結果集：資料記錄總數和要求的結果集。

　　傳回的記錄總數取決于要執行查詢，例如，一個where條件可以限制傳回的結果集的大小。因為在分頁界面中必須要根據資料集記錄的大小來計算總的頁數，是以必須要傳回結果集的記錄數。例如，如果一共有1000000條記錄，如果用where條件就可以過濾成隻傳回1000條記錄，存儲過程的分頁邏輯應該知道傳回那些需要顯示的資料。

三、連接配接池

　　用TCP來連接配接你的應用程式與資料庫是一件昂貴的事情（很費時的事情），微軟的開發者可以通過用連接配接池來反複的使用資料庫的連接配接。比起每次請求都用TCP來連一次資料庫，連接配接池隻有在不存在有效的連接配接時才建立一個TCP連接配接。當關閉一個連接配接的時候，它會被放到池中，它仍然會保持與資料庫的連接配接，這樣就可以減少與資料庫的TCP連接配接次數。

　　當然，你要注意那些忘記關的連接配接，你應在每次用完連接配接後馬上關閉它。要強調的是：無論什麼人說.net framework中的GC(垃圾收集器)總會在你用完連接配接對象後調用連接配接對象的Close或者Dispose方法顯式的關閉你的連接配接。不要期望CLR會在你想象的時間内關掉連接配接，雖然CLR最終都要銷毀對象和關閉邊接，但是我們并不能确定它到底會在什麼時候做這些事情。  

　　要用連接配接池優化，有兩條規則，第一，打開連接配接，處理資料，然後關閉連接配接。如果你必須在每次請求中多次打開或關閉連接配接，這好過一直打開一個邊接，然後把它傳到各個方法中。第二，用相同的連接配接字元串（或者用相同的使用者辨別，當你用內建認證的時候）。如果你沒有用相同的連接配接字元串，如你用基于登入使用者的連接配接字元串，這将不能利用連接配接池的優化功能。如果你用的是內建的論證，因為使用者很多，是以你也不能充分利用連接配接池的優化功能。.NET CLR提供了一個資料性能計數器，它在我們需要跟蹤程式性能特性的時候非常有用，當然也包括連接配接池的跟蹤了。      

　　無論你的應用程式什麼時候要連在另一台機子的資源，如資料庫，你都應該重點優化你連資源所花的時間，接收和發送資料的時間，以及往傳回之間的次數。優化你的應用程式中的每一個處理點（process hop），它是提高你的應用的性能的出發點。  

　　應用程式層包含與資料層連接配接，傳送資料到相應的類的執行個體以及業務處理的邏輯。例如，在Community Server中，要組裝一個Forums或者Threads集合，然後應用業務邏輯，如授權，更重要的，這裡要完成緩存邏輯。

四、ASP.NET緩存API

 　　在寫應用程式之前,你要做的第一件事是讓應用程式最大化的利用ASP.NET的緩存功能。

　　如果你的元件是要在Asp.net應用程式中運作，你隻要把System.Web.dll引用到你的項目中就可以了。然後用HttpRuntime.Cache屬性就可通路Cache了（也可以通過Page.Cache或HttpContext.Cache通路）。  

　　有以下幾條緩存資料的規則。第一，資料可能會被頻繁的被使用，這種資料可以緩存。第二，資料的通路頻率非常高，或者一個資料的通路頻率不高，但是它的生存周期很長，這樣的資料最好也緩存起來。第三是一個常常被忽略的問題，有時候我們緩存了太多資料，通常在一台X86的機子上，如果你要緩存的資料超過800M的話，就會出現記憶體溢出的錯誤。是以說緩存是有限的。換名話說，你應該估計緩存集的大小，把緩存集的大小限制在10以内，否則它可能會出問題。在Asp.net中，如果緩存過大的話也會報記憶體溢出錯誤，特别是如果緩存大的DataSet對象的時候。

這裡有幾個你必須了解的重要的緩存機制。首先是緩存實作了“最近使用”原則（ a least-recently-used algorithm），當緩存少的時候，它會自動的強制清除那些無用的緩存。其次 “條件依賴”強制清除原則（expiration dependencies），條件可以是時間，關鍵字和檔案。以時間作為條件是最常用的。在asp.net2.0中增加一更強的條件，就是資料庫條件。當資料庫中的資料發生變化時，就會強制清除緩存　　

五、預請求緩存

　　在前面，我們隻對某些地方作了一個小小的性能改進也可以獲得大的性能提升，用預請求緩存來提升程式的性能是很不錯的。

　　雖然Cache API設計成用來儲存某段時間的資料，而預請求緩存隻是儲存某個時期的某個請求的内容。如果某個請求的通路頻率高，而且這個請求隻需要提取，應用，修改或者更新資料一次。那麼就可以預緩存該請求。我們舉個例子來說明。

　　在BS的論壇應用程式中，每一個頁面的伺服器控件都要求得到用于決定它的皮膚（skin）的自定義的資料，以決定用哪個樣式表及其它的一些個性化的東西。這裡面的某些資料可能要長時間的儲存，有些時間則不然，如控件的skin資料，它隻需要應用一次，而後就可以一直使用。

　　要實作預請求緩存，用Asp.net 的HttpContext類，HttpContext類的執行個體在每一個請求中建立，在請求期間的任何地方都可以通過HttpContext.Current屬性通路。HttpContext類有一個Items集合屬性，在請求期間所有的對象和資料都被添加到這個集合中緩存起來。和你用Cache緩存通路頻率高資料一樣，你可以用HttpContext.Items緩存那些每個請求都要用到的基礎資料。它背後的邏輯很簡單：我們向HttpContext.Items中添加一個資料，然後再從它裡面讀出資料。

六、背景處理

　　通過上面的方法你的應用程式應該運作得很快了，是不是？但是在某些時候，程式中的一次請求中可能要執行一個非常耗時的任務。如發送郵件或者是檢查送出的資料的正确性等。

　　當我們把asp.net Forums 1.0內建在CS中的時侯，發現送出一個新的文章的時候會非常的慢。每次新增一個文章的時侯，應用程式首先要檢查這個文章是不是重複提的，然後用“badword”過濾器來過濾，檢查圖檔附加碼，作文章的索引，把它添加到合适的隊列中，驗證它的附件，最後，發郵件到它的訂閱者郵件箱中。顯然，這個工作量很大。

　　結果是它把大量的時間都花在做索引和發送郵件中了。做文章的索引是一項很耗時的操作，而發郵件給訂閱都需要連接配接到SMTP服務，然後給每一個訂閱者都發一封郵件，随着訂閱使用者的增加，發送郵件的時間會更長。

　　索引和發郵件并不需要在每次請求時觸發，理想狀态下，我們想要批量的處理這些操作，每次隻發25封郵件或者每隔5分鐘把所有的要發的新郵件發一次。我們決定使用與資料庫原型緩存一樣的代碼，但是失敗了，是以又不得不回到VS.NET 2005。

　　我們在System.Threading命名空間下找到了Timer類，這個類非常有用，但卻很少有人知道，Web開發人員則更少有人知道了。一旦他建了該類的執行個體，每隔一個指定的時間，Timer類就會從線程池中的一個線程中調用指定的回調函數。這意味着你的asp.net應用程式可以在沒有請求的時候也可以運作。這就是後以處理的解決方案。你就可以讓做索引和發郵件工作在背景運作，而不是在每次請求的時候必須執行。

　　背景運作的技術有兩個問題，第一是，當你的應用程式域解除安裝後，Timer類執行個體就會停止運作了。也就是不會調用回調方法了。另外，因為CLR的每個程序中都有許多的線程在運作，你将很難讓Timer獲得一個線程來執行它，或者能執行它，但會延時。Asp.net層要盡量少的使用這種技術，以減少程序中線程的數量，或者隻讓請求用一小部分的線程。當然如果你有大量的異步工作的話，那就隻能用它了。

七、頁面輸出緩存和代理服務

　　Asp.net是你的界面層（或者說應該是），它包含頁面，使用者控件，伺服器控件（HttpHandlers 和HttpModules）以及它們生成的内容。如果你有一個Asp.net頁面用來輸出html，xml,imgae或者是其它的資料，對每一個請求你都用代碼來生成相同的輸出内容，你就很有必要考慮用頁面輸出緩存了。

隻要簡單的把下面的這一行代碼複制到你的頁面中就可以實作了：

<%@ PageOutputCache VaryByParams=”none” Duration=”60” %>

就可以有效的利用第一次請求裡生成的頁面輸出緩存内容，60秒後重新生成一道頁面内容。這種技術其實也是運用一些低層的Cache API來實作。用頁面輸出緩存有幾個參數可以配置，如上面所說的VaryByParams參數，該參數表示什麼時候觸發重輸出的條件，也可以指定在Http Get或Http Post 請求模式下緩存輸出。例如當我們設定該參數為VaryByParams=”Report”的時候，default.aspx?Report=1或者default.aspx?Report=2請求的輸出都會被緩存起來。參數的值可以是多個用分号隔開參數。

　　許多人都沒有意識到當用頁面輸出緩存的時候，asp.net也會生成HTTP頭集（HTTP Header）儲存在下遊的緩存伺服器中，這些資訊可以用于Microsoft Internet安全性中以及加速伺服器的響應速度。當HTTP緩存的頭被重置時，請求的内容會被緩在網絡資源中，當用戶端再次請求該内容時，就不會再從源伺服器上獲得内容了，而直接從緩存中獲得内容。

　　雖然用頁面輸出緩存不提高你的應用程式性能，但是它能減少了從的伺服器中加載已緩存頁面内容的次數。當然，這僅限于緩存匿名使用者可以通路的頁面。因為一旦頁面被緩存後，就不能再執行授權操作了。

八、 用IIS6.0的Kernel Caching

　　如果你的應用程式沒用運作在IIS6.0(windows server 2003)中，那麼你就失去了一些很好的提高應用程式性能的方法。在第七個方法中，我講了用頁面輸出緩存提高應用程式的性能的方法。在IIS5.0中，當一個請求到來到IIS後，IIS會把它轉給asp.net，當應用了頁面輸出緩存時，ASP.NET中的HttpHandler會接到該請求，HttpHandler從緩存中把内容取出來并傳回。

　　如果你用的是IIS6.0，它有一個非常好的功能就是Kernel Caching，而且你不必修改asp.net程式中任何代碼。當asp.net接到一個已緩存的請求，IIS的Kernel Cache會從緩存中得到它的一份拷貝。當從網絡中傳來一個請求的時，Kernel層會得到該請求，如果該請求被緩存起來了，就直接把緩存的資料傳回，這樣就完工了。這就意味着當你用IIS的Kernel Caching來緩存頁面輸出時，你将獲得不可置信的性能提升。在開發VS.NET 2005的 asp.net時有一點，我是專門負asp.net性能的程式經理，我的程式員用了這個方法，我看了所有日報表資料，發現用kernel model caching的結果總是最快的。它們的一個共同的特征就是網絡的請求和響應量很大,但IIS隻占用了5%的CPU資源。這是令人驚奇的。有許多讓你使用用IIS6.0的理由，但kernel cashing是最好的一個。

九、 用Gzip壓縮資料

　　除非你的CPU占用率太高了，才有必要用提升伺服器性能的技巧。用gzip壓縮資料的方法可以減少你發送到服務端的資料量，也可以提高頁面的運作速度，同時也減少了網絡的流量。怎麼樣更好的壓縮資料取決于你要發送的資料，還有就是用戶端的浏覽器支不支援（IIS把用gzip壓縮後的資料發送到用戶端，用戶端要支援gzip才能解析，IE6.0和Firefox都支援）。這樣你的伺服器每秒能多響應一些請求，同樣，你也減少了發送響應的資料量，也就能多發送一些請求了。

　　好消息，gzip壓縮已經被內建在IIS6.0中了，它比IIS5.0中gzip更好。不幸的是，在IIS6.0中啟用gzip壓縮，你不能在IIS6.0的屬性對話中設定。IIS開發團隊把gzip壓縮功能開發出來了，但他們卻忘了在管理者視窗中讓管理者能很友善的啟用它。要啟用gzip壓縮，你隻能深入IIS6.0的xml配置檔案中修改它的配置。

　　除了閱讀本文以外看看Brad Wilson寫的 IIS6 壓縮一文：http://www.dotnetdevs.com/articles/IIS6compression.aspx；另外還有一篇介紹aspx壓縮基礎知識的文章，Enable ASPX Compression in IIS。但是要注意，在IIS6中動态壓縮和kernel cashing是互斥的。

十、 伺服器控件的ViewState

　　ViewState是asp.net中的一個特性，它用于把生成頁面要用的一狀态值儲存在一個隐藏域中。當頁面被回傳到伺服器時，伺服器要解析，校驗和應用ViewState中的資料以還原頁面的控件樹。ViewState是一個非常有用的特性，它能持久化用戶端的狀态而不用cookie或者伺服器的記憶體。大部分的伺服器控件都是用ViewState來持久化那些在頁面中與使用者互動的元素的狀态值。例如，用以儲存用于分頁的目前頁的頁碼。

　　用ViewState會帶來一些負面的影響。首先，它加大的伺服器的響應和請求的時間。其次，每次回傳時都增加了序列化和反序列化資料的時間。最後，它還消耗了伺服器更多的記憶體。

　　許多的伺服器控件很趨于使用ViewState，如DataGrid，而有時候是沒有必須使用的。預設情況下是允許使用ViewState的，如果你不想使用ViewState的話，你可以在控件或頁面級别把關閉它。在控件中，你隻要把EnableViewState屬性設為False就可以了；你也可以在頁面中設定，使它的範圍擴充到整個頁面中： <%@ Page EnableViewState=”false” %> 如果頁面無需回傳或者每次請求頁面隻是呈現控件。你就應該在頁面級别中把ViewState關掉。

1. C#語言方面

1.1 垃圾回收

　垃圾回收解放了手工管理對象的工作，提高了程式的健壯性，但副作用就是程式代碼可能對于對象建立變得随意。

　1.1.1 避免不必要的對象建立

　由于垃圾回收的代價較高，是以C#程式開發要遵循的一個基本原則就是避免不必要的對象建立。以下列舉一些常見的情形。

　1.1.1.1 避免循環建立對象 ★

　如果對象并不會随每次循環而改變狀态，那麼在循環中反複建立對象将帶來性能損耗。高效的做法是将對象提到循環外面建立。

　1.1.1.2 在需要邏輯分支中建立對象

　如果對象隻在某些邏輯分支中才被用到，那麼應隻在該邏輯分支中建立對象。

　1.1.1.3 使用常量避免建立對象

　程式中不應出現如 new Decimal(0) 之類的代碼，這會導緻小對象頻繁建立及回收，正确的做法是使用Decimal.Zero常量。我們有設計自己的類時，也可以學習這個設計手法，應用到類似的場景中。

　1.1.1.4 使用StringBuilder做字元串連接配接

1.1.2 不要使用空析構函數 ★

　如果類包含析構函數，由建立對象時會在 Finalize 隊列中添加對象的引用，以保證當對象無法可達時，仍然可以調用到 Finalize 方法。垃圾回收器在運作期間，會啟動一個低優先級的線程處理該隊列。相比之下，沒有析構函數的對象就沒有這些消耗。如果析構函數為空，這個消耗就毫無意 義，隻會導緻性能降低！是以，不要使用空的析構函數。

　在實際情況中，許多曾在析構函數中包含處理代碼，但後來因為種種原因被注釋掉或者删除掉了，隻留下一個空殼，此時應注意把析構函數本身注釋掉或删除掉。

　1.1.3 實作 IDisposable 接口

　垃圾回收事實上隻支援托管内在的回收，對于其他的非托管資源，例如 Window GDI 句柄或資料庫連接配接，在析構函數中釋放這些資源有很大問題。原因是垃圾回收依賴于内在緊張的情況，雖然資料庫連接配接可能已瀕臨耗盡，但如果記憶體還很充足的話，垃圾回收是不會運作的。

　 C#的 IDisposable 接口是一種顯式釋放資源的機制。通過提供 using 語句，還簡化了使用方式（編譯器自動生成 try ... finally 塊，并在 finally 塊中調用 Dispose 方法）。對于申請非托管資源對象，應為其實作 IDisposable 接口，以保證資源一旦超出 using 語句範圍，即得到及時釋放。這對于構造健壯且性能優良的程式非常有意義！

為防止對象的 Dispose 方法不被調用的情況發生，一般還要提供析構函數，兩者調用一個處理資源釋放的公共方法。同時，Dispose 方法應調用 System.GC.SuppressFinalize(this)，告訴垃圾回收器無需再處理 Finalize 方法了。

1.2 String 操作

　1.2.1 使用 StringBuilder 做字元串連接配接

　 String 是不變類，使用 + 操作連接配接字元串将會導緻建立一個新的字元串。如果字元串連接配接次數不是固定的，例如在一個循環中，則應該使用 StringBuilder 類來做字元串連接配接工作。因為 StringBuilder 内部有一個 StringBuffer ，連接配接操作不會每次配置設定新的字元串空間。隻有當連接配接後的字元串超出 Buffer 大小時，才會申請新的 Buffer 空間。典型代碼如下：StringBuilder sb = new StringBuilder( 256 );

for ( int i = 0 ; i < Results.Count; i ++ )

{

sb.Append (Results[i]);

}

如果連接配接次數是固定的并且隻有幾次，此時應該直接用 + 号連接配接，保持程式簡潔易讀。實際上，編譯器已經做了優化，會依據加号次數調用不同參數個數的 String.Concat 方法。例如：String str = str1 + str2 + str3 + str4;

　會被編譯為 String.Concat(str1, str2, str3, str4)。該方法内部會計算總的 String 長度，僅配置設定一次，并不會如通常想象的那樣配置設定三次。作為一個經驗值，當字元串連接配接操作達到 10 次以上時，則應該使用 StringBuilder。

　 這裡有一個細節應注意：StringBuilder 内部 Buffer 的預設值為 16 ，這個值實在太小。按 StringBuilder 的使用場景，Buffer 肯定得重新配置設定。經驗值一般用 256 作為 Buffer 的初值。當然，如果能計算出最終生成字元串長度的話，則應該按這個值來設定 Buffer 的初值。使用 new StringBuilder(256) 就将 Buffer 的初始長度設為了256。

　1.2.2 避免不必要的調用 ToUpper 或 ToLower 方法

　String是不變類，調用ToUpper或ToLower方法都會導緻建立一個新的字元串。如果被頻繁調用，将導緻頻繁建立字元串對象。這違背了前面講到的“避免頻繁建立對象”這一基本原則。

　例如，bool.Parse方法本身已經是忽略大小寫的，調用時不要調用ToLower方法。

　另一個非常普遍的場景是字元串比較。高效的做法是使用 Compare 方法，這個方法可以做大小寫忽略的比較，并且不會建立新字元串。

　 還有一種情況是使用 HashTable 的時候，有時候無法保證傳遞 key 的大小寫是否符合預期，往往會把 key 強制轉換到大寫或小寫方法。實際上 HashTable 有不同的構造形式，完全支援采用忽略大小寫的 key: new HashTable(StringComparer.OrdinalIgnoreCase)。

　1.2.3 最快的空串比較方法

　将String對象的Length屬性與0比較是最快的方法：if (str.Length == 0)

　其次是與String.Empty常量或空串比較：if (str == String.Empty)或if (str == "")

　注：C#在編譯時會将程式集中聲明的所有字元串常量放到保留池中（intern pool），相同常量不會重複配置設定。

1.3 多線程

1.3.1 線程同步

　線程同步是編寫多線程程式需要首先考慮問題。C#為同步提供了 Monitor、Mutex、AutoResetEvent 和 ManualResetEvent 對象來分别包裝 Win32 的臨界區、互斥對象和事件對象這幾種基礎的同步機制。C#還提供了一個lock語句，友善使用，編譯器會自動生成适當的 Monitor.Enter 和 Monitor.Exit 調用。

　1.3.1.1 同步粒度

　同步粒度可以是整個方法，也可以是方法中某一段代碼。為方法指定 MethodImplOptions.Synchronized 屬性将标記對整個方法同步。例如：[MethodImpl(MethodImplOptions.Synchronized)]

public static SerialManager GetInstance()

if (instance == null )

instance = new SerialManager();

return instance;

通常情況下，應減小同步的範圍，使系統獲得更好的性能。簡單将整個方法标記為同步不是一個好主意，除非能确定方法中的每個代碼都需要受同步保護。

　1.3.1.2 同步政策

　使用 lock 進行同步，同步對象可以選擇 Type、this 或為同步目的專門構造的成員變量。

　避免鎖定Type★

　 鎖定Type對象會影響同一程序中所有AppDomain該類型的所有執行個體，這不僅可能導緻嚴重的性能問題，還可能導緻一些無法預期的行為。這是一個很不 好的習慣。即便對于一個隻包含static方法的類型，也應額外構造一個static的成員變量，讓此成員變量作為鎖定對象。

　避免鎖定 this

　 鎖定 this 會影響該執行個體的所有方法。假設對象 obj 有 A 和 B 兩個方法，其中 A 方法使用 lock(this) 對方法中的某段代碼設定同步保護。現在，因為某種原因，B 方法也開始使用 lock(this) 來設定同步保護了，并且可能為了完全不同的目的。這樣，A 方法就被幹擾了，其行為可能無法預知。是以，作為一種良好的習慣，建議避免使用 lock(this) 這種方式。

　使用為同步目的專門構造的成員變量

　這是推薦的做法。方式就是 new 一個 object 對象， 該對象僅僅用于同步目的。

　如果有多個方法都需要同步，并且有不同的目的，那麼就可以為些分别建立幾個同步成員變量。

1.3.1.4 集合同步

　C#為各種集合類型提供了兩種友善的同步機制：Synchronized 包裝器和 SyncRoot 屬性。

// Creates and initializes a new ArrayList

ArrayList myAL = new ArrayList();

myAL.Add( " The " );

myAL.Add( " quick " );

myAL.Add( " brown " );

myAL.Add( " fox " );

// Creates a synchronized wrapper around the ArrayList

ArrayList mySyncdAL = ArrayList.Synchronized(myAL);

調用 Synchronized 方法會傳回一個可保證所有操作都是線程安全的相同集合對象。考慮 mySyncdAL[0] = mySyncdAL[0] + "test" 這一語句，讀和寫一共要用到兩個鎖。一般講，效率不高。推薦使用 SyncRoot 屬性，可以做比較精細的控制。

1.3.2 使用 ThreadStatic 替代 NameDataSlot ★

　存取 NameDataSlot 的 Thread.GetData 和 Thread.SetData 方法需要線程同步，涉及兩個鎖：一個是 LocalDataStore.SetData 方法需要在 AppDomain 一級加鎖，另一個是 ThreadNative.GetDomainLocalStore 方法需要在 Process 一級加鎖。如果一些底層的基礎服務使用了 NameDataSlot，将導緻系統出現嚴重的伸縮性問題。

　規避這個問題的方法是使用 ThreadStatic 變量。示例如下：public sealed class InvokeContext

[ThreadStatic]

private static InvokeContext current;

private Hashtable maps = new Hashtable();

1.3.3 多線程程式設計技巧

　1.3.3.1 使用 Double Check 技術建立對象internal IDictionary KeyTable

get

if ( this ._keyTable == null )

lock ( base ._lock)

this ._keyTable = new Hashtable();

return this ._keyTable;

建立單例對象是很常見的一種程式設計情況。一般在 lock 語句後就會直接建立對象了，但這不夠安全。因為在 lock 鎖定對象之前，可能已經有多個線程進入到了第一個 if 語句中。如果不加第二個 if 語句，則單例對象會被重複建立，新的執行個體替代掉舊的執行個體。如果單例對象中已有資料不允許被破壞或者别的什麼原因，則應考慮使用 Double Check 技術。

1.4 類型系統

　1.4.1 避免無意義的變量初始化動作

　CLR保證所有對象在通路前已初始化，其做法是将配置設定的記憶體清零。是以，不需要将變量重新初始化為0、false或null。

　需要注意的是：方法中的局部變量不是從堆而是從棧上配置設定，是以C#不會做清零工作。如果使用了未指派的局部變量，編譯期間即會報警。不要因為有這個印象而對所有類的成員變量也做指派動作，兩者的機理完全不同！

　1.4.2 ValueType 和 ReferenceType

1.4.2.1 以引用方式傳遞值類型參數

　值類型從調用棧配置設定，引用類型從托管堆配置設定。當值類型用作方法參數時，預設會進行參數值複制，這抵消了值類型配置設定效率上的優勢。作為一項基本技巧，以引用方式傳遞值類型參數可以提高性能。

　1.4.2.2 為 ValueType 提供 Equals 方法

　 .net 預設實作的 ValueType.Equals 方法使用了反射技術，依靠反射來獲得所有成員變量值做比較，這個效率極低。如果我們編寫的值對象其 Equals 方法要被用到（例如将值對象放到 HashTable 中），那麼就應該重載 Equals 方法。public struct Rectangle

public double Length;

public double Breadth;

public override bool Equals ( object ob)

if (ob is Rectangle)

return Equels ((Rectangle)ob))

else

return false ;

private bool Equals (Rectangle rect)

return this .Length == rect.Length && this .Breadth == rect.Breach;

1.4.2.3 避免裝箱和拆箱

　C#可以在值類型和引用類型之間自動轉換，方法是裝箱和拆箱。裝箱需要從堆上配置設定對象并拷貝值，有一定性能消耗。如果這一過程發生在循環中或是作為底層方法被頻繁調用，則應該警惕累計的效應。

　一種經常的情形出現在使用集合類型時。例如：ArrayList al = new ArrayList();

for ( int i = 0 ; i < 1000 ; i ++ )

al.Add(i); // Implicitly boxed because Add() takes an object

int f = ( int )al[ 0 ]; // The element is unboxed

1.5 異常處理

　異常也是現代語言的典型特征。與傳統檢查錯誤碼的方式相比，異常是強制性的（不依賴于是否忘記了編寫檢查錯誤碼的代碼）、強類型的、并帶有豐富的異常資訊（例如調用棧）。

　1.5.1 不要吃掉異常★

　關于異常處理的最重要原則就是：不要吃掉異常。這個問題與性能無關，但對于編寫健壯和易于排錯的程式非常重要。這個原則換一種說法，就是不要捕獲那些你不能處理的異常。

　吃掉異常是極不好的習慣，因為你消除了解決問題的線索。一旦出現錯誤，定位問題将非常困難。除了這種完全吃掉異常的方式外，隻将異常資訊寫入日志檔案但并不做更多處理的做法也同樣不妥。

　1.5.2 不要吃掉異常資訊★

　有些代碼雖然抛出了異常，但卻把異常資訊吃掉了。

　為異常披露詳盡的資訊是程式員的職責所在。如果不能在保留原始異常資訊含義的前提下附加更豐富和更人性化的内容，那麼讓原始的異常資訊直接展示也要強得多。千萬不要吃掉異常。

　1.5.3 避免不必要的抛出異常

　抛出異常和捕獲異常屬于消耗比較大的操作，在可能的情況下，應通過完善程式邏輯避免抛出不必要不必要的異常。與此相關的一個傾向是利用異常來控制處理邏輯。盡管對于極少數的情況，這可能獲得更為優雅的解決方案，但通常而言應該避免。

　1.5.4 避免不必要的重新抛出異常

　如果是為了包裝異常的目的（即加入更多資訊後包裝成新異常），那麼是合理的。但是有不少代碼，捕獲異常沒有做任何處理就再次抛出，這将無謂地增加一次捕獲異常和抛出異常的消耗，對性能有傷害。

1.6 反射

　反射是一項很基礎的技術，它将編譯期間的靜态綁定轉換為延遲到運作期間的動态綁定。在很多場景下（特别是類架構的設計），可以獲得靈活易于擴充的架構。但帶來的問題是與靜态綁定相比，動态綁定會對性能造成較大的傷害。

　1.6.1 反射分類

　 type comparison ：類型判斷，主要包括 is 和 typeof 兩個操作符及對象執行個體上的 GetType 調用。這是最輕型的消耗，可以無需考慮優化問題。注意 typeof 運算符比對象執行個體上的 GetType 方法要快，隻要可能則優先使用 typeof 運算符。

　member enumeration ： 成員枚舉，用于通路反射相關的中繼資料資訊，例如Assembly.GetModule、Module.GetType、Type對象上的 IsInterface、IsPublic、GetMethod、GetMethods、GetProperty、GetProperties、 GetConstructor調用等。盡管中繼資料都會被CLR緩存，但部分方法的調用消耗仍非常大，不過這類方法調用頻度不會很高，是以總體看性能損失程 度中等。

　member invocation：成員調用，包括動态建立對象及動态調用對象方法，主要有Activator.CreateInstance、Type.InvokeMember等。

　1.6.2 動态建立對象

　C#主要支援 5 種動态建立對象的方式：

　　1. Type.InvokeMember

　　2. ContructorInfo.Invoke

　　3. Activator.CreateInstance(Type)

　　4. Activator.CreateInstance(assemblyName, typeName)

　　5. Assembly.CreateInstance(typeName)

　最快的是方式 3 ，與 Direct Create 的差異在一個數量級之内，約慢 7 倍的水準。其他方式，至少在 40 倍以上，最慢的是方式 4 ，要慢三個數量級。

　1.6.3 動态方法調用

　 方法調用分為編譯期的早期綁定和運作期的動态綁定兩種，稱為Early-Bound Invocation和Late-Bound Invocation。Early-Bound Invocation可細分為Direct-call、Interface-call和Delegate-call。Late-Bound Invocation主要有Type.InvokeMember和MethodBase.Invoke，還可以通過使用LCG（Lightweight Code Generation）技術生成IL代碼來實作動态調用。

　從測試結果看，相比Direct Call，Type.InvokeMember要接近慢三個數量級；MethodBase.Invoke雖然比Type.InvokeMember要快三 倍，但比Direct Call仍慢270倍左右。可見動态方法調用的性能是非常低下的。我們的建議是：除非要滿足特定的需求，否則不要使用！

　1.6.4 推薦的使用原則

　模式

　　1． 如果可能，則避免使用反射和動态綁定

　　2． 使用接口調用方式将動态綁定改造為早期綁定

　　3． 使用Activator.CreateInstance(Type)方式動态建立對象

　　4． 使用typeof操作符代替GetType調用

　反模式

　　1． 在已獲得Type的情況下，卻使用Assembly.CreateInstance(type.FullName)

1.7 基本代碼技巧

　這裡描述一些應用場景下，可以提高性能的基本代碼技巧。對處于關鍵路徑的代碼，進行這類的優化還是很有意義的。普通代碼可以不做要求，但養成一種好的習慣也是有意義的。

　1.7.1 循環寫法

　 可以把循環的判斷條件用局部變量記錄下來。局部變量往往被編譯器優化為直接使用寄存器，相對于普通從堆或棧中配置設定的變量速度快。如果通路的是複雜計算屬性 的話，提升效果将更明顯。for (int i = 0, j = collection.GetIndexOf(item); i < j; i++)

　需要說明的是：這種寫法對于CLR集合類的Count屬性沒有意義，原因是編譯器已經按這種方式做了特别的優化。

　1.7.2 拼裝字元串

　拼裝好之後再删除是很低效的寫法。有些方法其循環長度在大部分情況下為1，這種寫法的低效就更為明顯了：public static string ToString(MetadataKey entityKey)

string str = "" ;

object [] vals = entityKey.values;

for ( int i = 0 ; i < vals.Length; i ++ )

str += " , " + vals[i].ToString();

return str == "" ? "" : str.Remove( 0 , 1 );

推薦下面的寫法：if (str.Length == 0 )

str = vals[i].ToString();

其實這種寫法非常自然，而且效率很高，完全不需要用個Remove方法繞來繞去。

　1.7.3 避免兩次檢索集合元素

　擷取集合元素時，有時需要檢查元素是否存在。通常的做法是先調用ContainsKey（或Contains）方法，然後再擷取集合元素。這種寫法非常符合邏輯。

　但如果考慮效率，可以先直接擷取對象，然後判斷對象是否為null來确定元素是否存在。對于Hashtable，這可以節省一次GetHashCode調用和n次Equals比較。

如下面的示例：public IData GetItemByID(Guid id)

IData data1 = null ;

if ( this .idTable.ContainsKey(id.ToString())

data1 = this .idTable[id.ToString()] as IData;

return data1;

其實完全可用一行代碼完成：return this.idTable[id] as IData;

　1.7.4 避免兩次類型轉換

　考慮如下示例，其中包含了兩處類型轉換： if (obj is SomeType)

SomeType st = (SomeType)obj;

st.SomeTypeMethod();

效率更高的做法如下：SomeType st = obj as SomeType;

if (st != null )

1.8 Hashtable

　Hashtable是一種使用非常頻繁的基礎集合類型。需要了解影響 Hashtable的效率有兩個因素：一是散列碼（GetHashCode方法），二是等值比較（Equals方法）。Hashtable首先使用鍵的散 列碼将對象分布到不同的存儲桶中，随後在該特定的存儲桶中使用鍵的Equals方法進行查找。

　良好的散列碼是第一位的因素，最理想的情況是每個不同的鍵都有不同的散列碼。Equals方法也很重要，因為散列隻需要做一次，而存儲桶中查找鍵可能需要做多次。從實際經驗看，使用Hashtable時，Equals方法的消耗一般會占到一半以上。

System.Object類提供了預設的GetHashCode實作，使用對象在記憶體中的位址作為散列碼。我們 遇到過一個用Hashtable來緩存對象的例子，每次根據傳遞的OQL表達式構造出一個ExpressionList對象，再調用 QueryCompiler的方法編譯得到CompiledQuery對象。以ExpressionList對象和CompiledQuery對象作為鍵 值對存儲到Hashtable中。ExpressionList對象沒有重載GetHashCode實作，其超類ArrayList也沒有，這樣最後用的 就是System.Object類的GetHashCode實作。由于ExpressionList對象會每次構造，是以它的HashCode每次都不 同，是以這個CompiledQueryCache根本就沒有起到預想的作用。這個小小的疏漏帶來了重大的性能問題，由于解析OQL表達式頻繁發生，導緻 CompiledQueryCache不斷增長，造成伺服器記憶體洩漏！解決這個問題的最簡單方法就是提供一個常量實作，例如讓散列碼為常量0。雖然這會導 緻所有對象彙聚到同一個存儲桶中，效率不高，但至少可以解決掉記憶體洩漏問題。當然，最終還是會實作一個高效的GetHashCode方法的。

　以上介紹這些Hashtable機理，主要是希望大家了解：如果使用Hashtable，你應該檢查一下對象是否提供了适當的GetHashCode和Equals方法實作。否則，有可能出現效率不高或者與預期行為不符的情況。

　2. Ado.Net

2.1 應用Ado.net的一些思考原則

　　1. 根據資料使用的方式來設計資料通路層

　　2. 緩存資料，避免不必要的操作

　　3. 使用服務帳戶進行連接配接

　　4. 必要時申請，盡早釋放

　　5. 關閉可關閉的資源

　　6. 減少往返

　　7. 僅傳回需要的資料

　　8. 選擇适當的事務類型

　　9. 使用存儲過程

2.2 Connection

　資料庫連接配接是一種共享資源，并且打開和關閉的開銷較大。Ado.net默 認啟用了連接配接池機制，關閉連接配接不會真的關閉實體連接配接，而隻是把連接配接放回到連接配接池中。因為池中共享的連接配接資源始終是有限的，如果在使用連接配接後不盡快關閉連 接，那麼就有可能導緻申請連接配接的線程被阻塞住，影響整個系統的性能表現。

　2.2.1 在方法中打開和關閉連接配接

　這個原則有幾層含義：

　　1. 主要目的是為了做到必要時申請和盡早釋放

　　2. 不要在類的構造函數中打開連接配接、在析構函數中釋放連接配接。因為這将依賴于垃圾回收，而垃圾回收隻受記憶體影響，回收時機不定

　　3. 不要在方法之間傳遞連接配接，這往往導緻連接配接保持打開的時間過長

這裡強調一下在方法之間傳遞連接配接的危害：曾經在壓力測試中遇到過一個測試案例，當增大使用者數的時候，這個案例要比 别的案例早很久就用掉連接配接池中的所有連接配接。經分析，就是因為A方法把一個打開的連接配接傳遞到了B方法，而B方法又調用了一個自行打開和關閉連接配接的C方法。在 A方法的整個運作期間，它至少需要占用兩條連接配接才能夠成功工作，并且其中的一條連接配接占用時間還特别長，是以造成連接配接池資源緊張，影響了整個系統的可伸縮 性！

2.2.2 顯式關閉連接配接

　Connection對象本身在垃圾回收時可以被關閉，而依賴垃圾回收是很不好的政策。推薦使用using語句顯式關閉連接配接，如下例：using (SqlConnection conn = new SqlConnection(connString))

conn.Open();

} // Dispose is automatically called on the conn variable here

2.2.3 確定連接配接池啟用

　Ado.net是為每個不同的連接配接串建立連接配接池，是以應該確定連接配接串不會出現與具體使用者相關的資訊。另外，要注意連接配接串是大小寫敏感的。

　2.2.4 不要緩存連接配接

　例如，把連接配接緩存到Session或Application中。在啟用連接配接池的情況下，這種做法沒有任何意義。

　2.3 Command

　2.3.1 使用ExecuteScalar和ExecuteNonQuery

　 如果想傳回像Count(*)、Sum(Price)或Avg(Quantity)那樣的單值，可以使用ExecuteScalar方法。 ExecuteScalar傳回第一行第一列的值，将結果集作為标量值傳回。因為單獨一步就能完成，是以ExecuteScalar不僅簡化了代碼，還提 高了性能。

　使用不傳回行的SQL語句時，例如修改資料（INSERT、UPDATE或DELETE）或僅傳回輸出參數或傳回值，請使用ExecuteNonQuery。這避免了用于建立空DataReader的任何不必要處理。

　2.3.2 使用Prepare

　當需要重複執行同一SQL語句多次，可考慮使用Prepare方法提升效率。需要注意的是，如果隻是執行一次或兩次，則完全沒有必要。例如：

cmd.CommandText = "insert into Table1 ( Col1, Col2 ) values ( @val1, @val2 )";

cmd.Parameters.Add( "@val1", SqlDbType.Int, 4, "Col1" );

cms.Parameters.Add( "@val2", SqlDbType.NChar, 50, "Col2");

cmd.Parameters[0].Value = 1;

cmd.Parameters[1].Value = "XXX";

cmd.Prepare();

cmd.ExecuteNonQuery();

cmd.Parameters[0].Value = 2;

cmd.Parameters[1].Value = "YYY";

cmd.Parameters[0].Value = 3;

cmd.Parameters[1].Value = "ZZZ";

2.3.3 使用綁定變量 ★

　SQL語句需要先被編譯成執行計劃，然後再執行。如果使用綁定變量的方 式，那麼這個執行計劃就可以被後續執行的SQL語句所複用。而如果直接把參數合并到了SQL語句中，由于參數值千變萬化，執行計劃就難以被複用了。例如上 面Prepare一節給出的示例，如果把參數值直接寫到insert語句中，那麼上面的四次調用将需要編譯四次執行計劃。

　為避免這種情況造成性能損失，要求一律使用綁定變量方式。

　2.4 DataReader

　 DataReader最适合于通路隻讀的單向資料集。與DataSet不同，資料集并不全部在記憶體中，而是随不斷發出的read請求，一旦發現資料緩沖區 中的資料均被讀取，則從資料源傳輸一個資料緩沖區大小的資料塊過來。另外，DataReader保持連接配接，DataSet則與連接配接斷開。

　2.4.1 顯式關閉DataReader

　 與連接配接類似，也需要顯式關閉DataReader。另外，如果與DataReader關聯的Connection僅為DataReader服務的話，可考 慮使用Command對象的ExecuteReader(CommandBehavior.CloseConnection)方式。這可以保證當 DataReader關閉時，同時自動關閉Connection。

　2.4.2 用索引号通路代替名稱索引号通路屬性

　從Row中通路某列屬性，使用索引号的方式比使用名稱方式有細微提高。如果會被頻繁調用，例如在循環中，那麼可考慮此類優化。示例如下：

cmd.CommandText = "select Col1, Col2 from Table1" ;

SqlDataReader dr = cmd.ExecuteReader();

int col1 = dr.GetOrdinal("Col1");

int col2 = dr.GetOrdinal("Col2");

while (dr.Read())

Console.WriteLine( dr[col1] + "_" + dr[col2]);

2.4.3 使用類型化方法通路屬性

　從Row中通路某列屬性，用GetString、GetInt32這種顯式指明類型的方法，其效率較通用的GetValue方法有細微提高，因為不需要做類型轉換。

　2.4.4 使用多資料集

　部分場景可以考慮一次傳回多資料集來降低網絡互動次數，提升效率。示例如下：

cmd.CommandText = "StoredProcedureName"; // The stored procedure returns multiple result sets.

while (dr.read())

// read first result set

dr.NextResult();

//

2.5 DataSet

　2.5.1 利用索引加快查找行的效率

　如果需要反複查找行，建議增加索引。有兩種方式：

　1. 設定DataTable的PrimaryKey

　适用于按PrimaryKey查找行的情況。注意此時應調用DataTable.Rows.Find方法，一般慣用的Select方法不能利用索引。

　2. 使用DataView

　适用于按Non-PrimaryKey查找行的情況。可為DataTable建立一個DataView，并通過SortOrder參數訓示建立索引。此後使用Find或FindRows查找行。

3.1 減少往返行程（Reduce Round Trips）

　使用下面的方法可以減少Web伺服器和Browser之間的往返行程：

　1. 為Browser啟用緩存

　如果呈現的内容是靜态的或變化周期較長，應啟用Browser緩存，避免發出備援的http請求。

2. 緩沖頁面輸出

　如果可能，則盡量緩沖頁面輸出，處理結束後再一次傳送到用戶端，這可以避免頻繁傳遞 小塊内容所造成的多次網絡互動。由于這種方式在頁面處理結束之前用戶端無法看到頁面内容，是以如果一個頁面的尺寸較大的話，可考慮使用 Response.Flush方法。該方法強制輸出迄今為止在緩沖區中的内容，你應當采用合理的算法控制調用Response.Flush方法的次數。

3. 使用Server.Transfer重定向請求

　使用Server.Transfer方法重定向請 求優于Response.Redirect方法。原因是Response.Redirect會向Broswer回送一個響應頭，在響應頭中指出重定向的 URL，之後Brower使用新的URL重新送出請求。而Server.Transfer方法直接是一個簡單的服務端調用，完全沒有這些開銷！

　需要注意Server.Transfer有局限性：第一，它會跳過安全檢查；第二，隻适用于在同一Web應用内的頁面間跳轉。

3.2 避免阻塞和長時間的作業

　如果需要運作阻塞或長時間運作的操作，可以考慮使用異步調用的機制，以便Web伺服器能夠繼續處理其它的請求。

　1. 使用異步方式調用Web服務和遠端對象

　隻要有可能就要避免在請求的處理過程中對Web服務和遠端對象的同步調用，因為它占用的是的ASP.NET 線程池中的工作線程，這将直接影響Web伺服器響應其它請求的能力。

2. 考慮給不需要傳回值的Web方法或遠端對象的方法添加OneWay屬性

　這種模式能讓Web Server調用之後就立即傳回。可根據實際情況決定是否使用這種方法。

3. 使用工作隊列

　将作業送出到伺服器上的工作隊列中。用戶端通過發送請求來輪詢作業的執行結果。

3.3 使用緩存

　緩存能在很大程度上決定ASP.NET應用的最終性能。Asp.net支援頁面輸出緩存和頁面部分緩存，并提供Cache API，供應用程式緩存自己的資料。是否使用緩存可考慮下面的要點：

　　1. 識别建立與通路代價較大的資料

　　2. 評估需要緩存資料的易變性

　　3. 評估資料的使用頻次

　　4. 将要緩存資料中易變資料和不變資料分離，隻緩存不變資料

　　5. 選擇合适的緩存機制（除Asp.net Cache外，Application state和Session state也可以作為緩存使用）

3.4 多線程

　1. 避免在請求處理過程中建立線程

　在執行請求的過程中建立線程是一種代價較大的操作，會嚴重影響Web Server的性能。如果後續的操作必須用線程完成，建議通過thread pool來建立/管理線程。

2. 不要依賴線程資料槽或線程靜态變量

　由于執行請求的線程是ASP.NET thread pool中的工作線程，同一個Client的兩次請求不一定由相同的線程來處理。

3. 避免阻塞處理請求的線程

　參考"避免阻塞和長時間的作業"小節。

4. 避免異步調用

　這和1的情況類似。異步調用會導緻建立新的線程，增加伺服器的負擔。是以，如果沒有并發的作業要執行，就不要執行異步調用。

3.5 系統資源

　　1. 考慮實作資源池以提升性能

　　2. 明确地調用Dispose或Close釋放系統資源

　　3. 不要緩存或長時間占用資源池中的資源

　　4. 盡可能晚的申請，盡可能早的釋放

3.6 頁面處理

　1. 盡量減小Page的尺寸

　包括縮短控件的名稱、CSS的class的名稱、去掉無謂空行和空格、禁用不需要的ViewState

　2. 啟用頁面輸出的緩沖區（Buffer）

　如果Buffer的機制被關閉，可以用下面的方法打開。

　使用程式打開頁面輸出緩存：

　Response.BufferOutput = true;

使用@Page開關打開頁面輸出緩沖機制：

　<%@ Page Buffer = "true" %>

使用Web.config或Machine.config配置檔案的<pages>節點：

　<pages buffer="true" …>

　3. 利用Page.IsPostBack優化頁面輸出

　4. 通過分離頁面的不同的内容，來提高緩存效率和減少呈現的時間

　5. 優化複雜和代價較大的循環

　6. 合理利用用戶端的計算資源，将一些操作轉移到用戶端進行

3.7 ViewState

　ViewState是Asp.net為服務端控件在頁面回傳之間跟蹤狀态資訊而設計的一種機制。

　1. 關閉ViewState

　 如果不需要跟蹤頁面狀态，例如頁面不會 回傳（PostBack）、不需要處理服務端控件事件或者每次頁面重新整理時都會重新計算控件内容，那麼就不需要用ViewState來記錄頁面狀态了。可以 對特定的WebControl設定EnableViewState屬性，也可以在頁面一級設定：

　<%@ Page EnableViewState="false" %>

2. 在恰當的時間點初始化控件屬性

　ASP.NET的控件在執行構造函數、初始化的期間設定的屬性不會被跟蹤變化；而在初始化階段之後對屬性的修改都會被跟蹤，并最終記錄到IE頁面的__VIEWSTATE之中。是以，選擇合理的初始化控件屬性的執行點，能有效的減小頁面尺寸。

3. 謹慎選擇放到ViewState中的内容

　放到ViewState中的内容會被序列化/反序列 化，Asp.net為String、Integer、Boolean等基本類型的序列化做了優化，如果Array、ArrayList、 HashTable存儲的是基本類型效率也較高，但其它類型則需要提供類型轉換器（Type Converter），否則将使用代價昂貴的二進制序列化程式。

4.1 JScript性能優化的基本原則

　1. 盡可能少地減少執行次數。畢竟對解釋語言來說，每一個執行步驟，都需要和解釋引擎做一次互動。

　2. 盡可能使用語言内置的功能，比如串連結。

　3. 盡可能使用系統提供的API來進行優化。因為這些API是編譯好的二進制代碼，執行效率很高。

　4. 書寫最正确的代碼。容錯功能是要付出性能代價的。

4.2 JScript語言本身的優化

　4.2.1 變量

　1. 盡量使用局部變量。

　因為全局變量其實是全局對象的成員，而局部變量在棧上定義，優先查找，性能相對于全局變量要高。

2. 盡量在一個語句中做定義變量和指派。

3. 省略不必要的變量定義。

　如果變量的定義可以被一個常量替代，就直接使用常量。

4. 使用Object文法對對象指派。

　Object的指派文法在操作複雜對象時效率更高。

　例如，可以将下面的代碼：

car = new Object();

car.make = "Honda";

car.model = "Civic";

car.transmission = "manual";

car.miles = 100000;

car.condition = "needs work";

替換成：

car = {

make: "Honda",

model: "Civic",

transmission: "manual",

miles: 100000,

condition: "needs work"

4.2.2 對象緩存

　1. 緩存對象查找的中間結果。

　因為JavaScript的解釋性，是以a.b.c.d.e，需要進行至少4次查詢操作，先檢查a再檢查a中的b，再檢查b中的c，如此往下。是以如果這樣的表達式重複出現，隻要可能，應該盡量少出現這樣的表達式，可以利用局部變量，把它放入一個臨時的地方進行查詢。

2. 緩存建立時間較長的對象。

　自定義進階對象和Date、RegExp對象在構造時都會消耗大量時間。如果可以複用，應采用緩存的方式。

4.2.3 字元串操作

　1. 使用"+=" 追加字元串，使用"+"來連接配接字元串。

　如果是追加字元串，最好使用s+=anotherStr操作，而不是要使用s=s+anotherStr。

　如果要連接配接多個字元串，應該使用"+"，如：

　　s+=a;

　　s+=b;

　　s+=c;

　　應該寫成

　　s+=a + b + c；

2. 連接配接大量的字元串，應使用Array的join方法。

　如果是收集字元串，最好使用JavaScript數組緩存，最後使用join方法連接配接起來，如下：

var buf = new Array();

for (var i = 0; i < 100; i++)

buf.push(i.toString());

var all = buf.join("");

4.2.4 類型轉換

　1. 使用Math.floor()或者Math.round()将浮點數轉換成整型。

　浮點數轉換成整型，這個更容易出錯，很多人喜歡使用parseInt()，其實parseInt()是用于将字元串轉換成數字，而不是浮點數和整型之間的轉換，我們應該使用Math.floor()或者Math.round()。

　對象查找中的問題不一樣，Math是内部對象，是以Math.floor()其實并沒有多少查詢方法和調用的時間，速度是最快的。

2. 自定義的對象，推薦定義和使用toString()方法來進行類型轉換。

　對于自定義的對象，如果定義了toString()方法來進行類型轉換的話，推薦顯式調用toString()。因為内部的操作在嘗試所有可能性之後，會嘗試對象的toString()方法嘗試能否轉化為String，是以直接調用這個方法效率會更高。

4.2.5 循環的優化

　1. 盡可能少使用for(in)循環。

　在JavaScript中，我們可以使用for(;;),while(),for(in)三種循環，事實上，這三種循環中for(in)的效率極差，因為他需要查詢散列鍵，隻要可以就應該盡量少用。

2. 預先計算collection的length。

　如：将for (var i = 0; i < collection.length; i++)

　替換成：for (var i = 0, len = collection.length; i < len; i++)

　效果會更好，尤其是在大循環中。

3. 盡量減少循環内的操作。

　循環内的每個操作，都會被放大為循環次數的倍數。是以，大循環内微小的改進，在性能的整體提升上都是可觀的。

4. 使用循環替代遞歸。

　相比循環，遞歸的效率更差一些。遞歸的優點是在形式上更自然一些。是以，在不影響代碼的維護性的前提下，用循環替代遞歸。

4.2.6 其它方面

　1. 盡量使用語言内置的文法。

　"var arr = […];"和"var arr = new Array(…);"是等效的，但是前者的效能優于後者。同樣，"var foo = {};"的方式也比"var foo = new Object();"快；"var reg = /../;"要比"var reg=new RegExp()"快。

2. 盡量不要使用eval。

　使用eval，相當于在運作時再次調用解釋引擎，對傳入的内容解釋運作，需要消耗大量時間。

3. 使用prototype代替closure。

　使用closure在性能和記憶體消耗上都是不利的。如果closure使用量過大，這就會成為一個問題。是以，盡量将：

　this.methodFoo = function()

　替換成：

　MyClass.protoype.methodFoo = function()

　和closure存在于對象執行個體之中不同，prototype存在于類中，被該類的所有的對象執行個體共享。

4. 避免使用with語句。

　With語句臨時擴充對象查找的範圍，節省了文字的錄入時間，但付出了更多的執行時間。因為每個給出的名稱都要在全局範圍查找。是以，可以将下面的代碼：

with (document.formname)

field1.value = "one";

field2.value = "two";

變更為：

var form = document.formname;

form.field1.value = "one";

form.field2.value = "two";

4.3 DOM相關

　4.3.1 建立DOM節點

　相比較通過document.write來給頁面生成内容，找一個容器元素（比如指定一個div或者span）并設定他們的innerHTML效率更高。

　而設定innerHTML的方式比通過createElement方法建立節點的效率更高。事實上，設定元素的innerHTML是建立節點效率最高的一種方式。

　 如果必須使用createElement方法，而如果文檔中存在現成的樣闆節點，應該是用cloneNode()方法。因為使用 createElement()方法之後，你需要設定多次元素的屬性，使用cloneNode()則可以減少屬性的設定次數。同樣，如果需要建立很多元 素，應該先準備一個樣闆節點。

4.3.2 離線操作大型的DOM樹

　在添加一個複雜的DOM樹時，可以先構造，構造結束後再将其添加到DOM數的适當節點。這能夠節省界面重新整理的時間。

同樣，在準備編輯一個複雜的樹時，可以先将樹從DOM樹上删除，等編輯結束後再添加回來。

　4.3.3 對象查詢

　使用[""]查詢要比.item()更快。調用.item()增加了一次查詢和函數的調用。

4.3.4 定時器

　如果針對的是不斷運作的代碼，不應該使用setTimeout，而應該用setInterval。setTimeout每次要重新設定一個定時器。

4.4 其他

　1. 盡量減小檔案尺寸。

　将JScript檔案中無關的空行、空格、注釋去掉，有助于減小JS檔案的尺寸，提高下載下傳的時間。（可以通過工具來支援代碼釋出）

　2. 盡量不要在同一個Page内同時引用JScript和VBScript引擎

　3. 将Page内的JScript移入到單獨的JS檔案中。

　4. 将Page内的JScript放置在Page的最下面，有助于提高頁面的響應速度。

　5. 利用cache，減少JScript檔案的下載下傳次數

　6. 在HTML内書寫JScript檔案的URL時，注意統一大小寫。這樣可以利用前面URL緩存的檔案。

　7. 推薦使用JScript Lint檢查Javascript代碼。畢竟，對JScript引擎來說，最容易了解的JScript代碼，執行的效率也就最高。