string是一種很特殊的資料型別,它既是基元型別又是引用型別,在編譯以及執行時,.Net都對它做了一些優化工作,正式這些優化工作有時會迷惑程式設計人員,使string看起來難以琢磨。這篇文章共四節,來講講關於string的陌生一面。

一.恆定的字串

要想比較全面的瞭解stirng型別,首先要清楚.Net中的值型別與引用型別。

在C#中,以下資料型別為值型別: bool、byte、char、enum、sbyte以及數字型別(包括可空型別)
         以下資料型別為引用型別: class、interface、delegate、object、stirng
看到了嗎,我們要討論的stirng赫然其中。被宣告為string型變數存放於堆中,是一個徹頭徹尾的引用型別。那麼許多同學就會對如下程式碼產生有疑問了,難道string型別也會“牽一髮而動全身”嗎?讓我們先來看看以下三行程式碼有何玄機:

string a = "str_1";
string b = a;
a = "str_2";

不要說無聊,這一點時必須講清楚的!在以上程式碼中,第3行的“=”有一個隱藏的祕密:它的作用我們可以理解為新建,而不是對變數“a”的修改。以下是IL程式碼,可以說明這一點:

.maxstack
.locals init ([] string a,[] string b)
IL_0000: nop
IL_0001: ldstr "str_1"
IL_0006: stloc.
IL_0007: ldloc.
IL_0008: stloc.
IL_0009: ldstr "str_2"
IL_000e: stloc. //以上2行對應 C#程式碼 a = "str_2";
IL_0015: ret

  可以看出IL程式碼的第1、6行,由ldstr指令建立字串"str_1",並將其關聯到了變數“a”中;7、8行直接將堆疊頂部的值彈出並關聯到變數“b”中;9、10由ldstr建立字串"str_2",關聯在變數“a”中(並沒有像我們想象的那樣去修改變數a的舊值,而是產生了新的字串);

  在C#中,如果用new關鍵字例項化一個類,對應是由IL指令newobj來完成的;而建立一個字串,則由ldstr指令完成,看到ldstr指令,我們即可認為,IL希望建立一個新的字串 。(注意:是IL希望建立一個字串,而最終是否建立,還要在執行時由字串的駐留機制決定,這一點下面的章節會有介紹。)

  所以,第三行C#程式碼(a = "str_2";)的樣子看起來是在修改變數a的舊值"str_1",但實際上是建立了一個新的字串"str_2",然後將變數a的指標指向了"str_2"的記憶體地址,而"str_1"依然在記憶體中沒有受到任何影響,所以變數b的值沒有任何改變---這就是string的恆定性,同學們,一定要牢記這一點,在.Net中,string型別的物件一旦建立即不可修改!包括ToUpper、SubString、Trim等操作都會在記憶體中產生新的字串。

本節重點回顧:由於stirng型別的恆定性,讓同學友們經常誤解,string雖屬引用型別但經常表現出值的特性,這是由於不瞭解string的恆定性造成的,根本不是“值的特性”。例如:

string a = "str_1";
a = "str_2";

這樣會在記憶體中建立"str_1"和"str_2"兩個字串,但只有"str_2"在被使用,"str_1"不會被修改或消失,這樣就浪費了記憶體資源,這也是為什麼在做大量字串操作時,推薦使用StringBuilder的原因。

二..Net中字串的駐留(重要)

  在第一節中,我們講了字串的恆定性,該特性又為我們引出了字串的另一個重要特性:字串駐留。
  從某些方面講,正是字串的恆定性,才造就了字串的駐留機制,也為字串的執行緒同步工作大開方便之門(同一個字串物件可以在不同的應用程式域中被訪問,所以駐留的字串是程序級的,垃圾回收不能釋放這些字串物件,只有程序結束這些物件才被釋放)。
我們用以下2行程式碼來說明字串的駐留現象:

string a = "str_1";
string b = "str_1";

  請各位同學友思考一下,這2行程式碼會在記憶體中產生了幾個string物件?你可能會認為產生2個:由於聲明瞭2個變數,程式第1行會在記憶體中產生"str_1"供變數a所引用;第2行會產生新的字串"str_1"供變數b所引用,然而真的是這樣嗎?我們用ReferenceEquals這個方法來看一下變數a與b的記憶體引用地址:

string a = "str_1";
string b = "str_1";
Response.Write(ReferenceEquals(a,b)); //比較a與b是否來自同一記憶體引用
//輸出:True

  哈,各位同學看到了嗎,我們用ReferenceEquals方法比較a與b,雖然我們聲明瞭2個變數,但它們竟然來自同一記憶體地址!這說明string b = "str_1";根本沒有在記憶體中產生新的字串。

  這是因為,在.Net中處理字串時,有一個很重要的機制,叫做字串駐留機制。由於string是程式設計中用到的頻率較高的一種型別,CLR對相同的字串,只分配一次記憶體。CLR內部維護著一塊特殊的資料結構,我們叫它字串池,可以把它理解成是一個HashTable,這個HashTable維護著程式中用到的一部分字串,HashTable的Key是字串的值,而Value則是字串的記憶體地址。一般情況下,程式中如果建立一個string型別的變數,CLR會首先在HashTable遍歷具有相同Hash Code的字串,如果找到,則直接把該字串的地址返回給相應的變數,如果沒有才會在記憶體中新建一個字串物件。

  所以,這2行程式碼只在記憶體中產生了1個string物件,變數b與a共享了記憶體中的"str_1"。

好了,結合第一節所講到的字串恆定性與第二節所講到的駐留機制,來理解一下下面3行程式碼吧:

string a = "str_1"; //宣告變數a,將變數a的指標指向記憶體中新產生的"str_1"的地址
a = "str_2"; //CLR先會在字串池中遍歷,檢視"str_2"是否已存在,如果沒有,則新建"str_2",並修改變數a的指標,指向"str_2"記憶體地址,"str_1"保持不變。(字串恆定)
string c = "str_2"; //CLR先會在字串池中遍歷"str_2"是否已存在,如果存在,則直接將變數c的指標指向"str_2"的地址。(字串駐留)

那麼如果是動態建立字串呢?字串還會不會有駐留現象呢?

我們分3種情況講解動態建立字串時,駐留機制的表現:

(1).字串常量連線

string a = "str_1" + "str_2";
string b = "str_1str_2";
Response.Write(ReferenceEquals(a,b)); //比較a與b是否來自同一記憶體引用
//輸出 :True

IL程式碼:

.maxstack
.locals init ([] string a,[] string b)
IL_0000: nop
IL_0001: ldstr “str_1str_2”
IL_0006: stloc.
IL_0007: ldstr “str_1str_2”
IL_000c: stloc.
IL_000d: ret

  其中第1、6行對應c#程式碼string a = “str_1” + “str_2”;第7、8對應c# string b = “str_1str_2”;可以看出,字串常量連線時,程式在被編譯為IL程式碼前,編譯器已經計算出了字串常量連線的結果,ldstr指令直接處理編譯器計算後的字串值,所以這種情況字串駐留機制有效!

(2).字串變數連線

string a = "str_1";
string b = a + "str_2";
string c = "str_1str_2";
Response.Write(ReferenceEquals(b,c));
//輸出:False

IL程式碼:

.maxstack
.locals init ([] string a, [] string b, [] string c)
IL_0000: nop
IL_0001: ldstr “str_1”
IL_0006: stloc.
IL_0007: ldloc.
IL_0008: ldstr “str_2”
IL_000d: call string [mscorlib]System.String::Concat(string,string)
IL_0012: stloc.
IL_0013: ldstr “str_1str_2”
IL_0018: stloc.
IL_0019: ret

  其中第1、6行對應string a = “str_1”;第7、8、9行對應string b = a + “str_2”;,IL用的是Concat方法連線字串,第13、18行對應string c = “str_1str_2”;可以看出,字串變數連線時,IL使用Concat方法,在執行時生成最終的連線結果,所以這種情況字串駐留機制無效!

(3).顯式例項化

string a = "a";
string b = new string('a',);
Response.Write(ReferenceEquals(a, b));
//輸出 False

IL程式碼:

.maxstack
.locals init ([] string a,[] string b)
IL_0000: nop
IL_0001: ldstr "a"
IL_0006: stloc.
IL_0007: ldc.i4.s
IL_0009: ldc.i4.
IL_000a: newobj instance void [mscorlib]System.String::.ctor(char, int32)
IL_000f: stloc.
IL_0010: ret

  這種情況比較好理解,IL使用newobj來例項化一個字串物件,駐留機制無效。從string b = new string('a',1);這行程式碼我們可以看出,其實string型別實際上是由char[]實現的,一個string的誕生絕不像我們想想的那樣簡單,要由棧、堆同時配合,才會有一個string的誕生。這一點在第四節會有介紹。

當然,當字串駐留機制無效時,我們可以很簡便的使用string.Intern方法將其手動駐留至字串池中,例如以下程式碼:

string a = "a";
string b = new string('a',);    
Response.Write(ReferenceEquals(a, string.Intern(b)));
//輸出:True (程式返回Ture,說明變數"a"與"b"來自同一記憶體地址。)

三.有趣的比較操作

  在第一節與第二節中,我們分別介紹了字串的恆定性與與駐留性,如果這位同學友覺得完全掌握了以上內容,那麼就在第三節中檢驗一下自己的學習成果吧!以下10段簡單的程式碼將通過值比較與地址引用比較,來說明前兩節講到的內容,大家也可以通過這些程式碼來檢測一下自己對string的瞭解程度。

程式碼一:

string a = "str_1";
string b = "str_1";
Response.Write(a.Equals(b));
Response.Write(ReferenceEquals(a,b)); //輸出:True (Equals比較字串物件的值)
//輸出:True (ReferenceEquals比較字串物件的引用,由於字串駐留機制,a與b的引用相同)

程式碼二:

string a = "str_1str_2";
string b = "str_1";
string c = "str_2";
string d = b + c;
Response.Write(a.Equals(d));
Response.Write(ReferenceEquals(a, d)); //輸出:True (Equals比較字串物件的值)
//輸出:False(ReferenceEquals比較字串物件的引用,由於變數d的值為變數連線的結果,字串駐留機制無效)

程式碼三:

string a = "str_1str_2";
string b = "str_1" + "str_2";
Response.Write(a.Equals(b));
Response.Write(ReferenceEquals(a, b)); //輸出:True (Equals比較字串物件的值)
//輸出:True (ReferenceEquals比較字串物件的引用,由於變數b的值為常量連線的結果,字串駐留機制有效。如果變數b的值由“常量+變數”的方式得出,則字串駐留無效)

程式碼四:

string a = "str_1";
string b = String.Copy(a);
Response.Write(a.Equals(b));
Response.Write(ReferenceEquals(a, b)); //輸出:True (Equals比較字串物件的值)
//輸出:False(ReferenceEquals比較字串物件的引用,Copy操作產生了新的string物件)

程式碼五:

string a = "str_1";
string b = String.Copy(a);
b = String.Intern(b);
Response.Write(a.Equals(b));
Response.Write(ReferenceEquals(a, b)); //輸出:True (Equals比較字串物件的值)
//輸出:True (ReferenceEquals比較字串物件的引用,String.Intern實現了字串駐留)

程式碼六:

string a = "str_1";
string b = String.Copy(a);
string c = "str_1";
Response.Write((object)a == (object)b);
Response.Write((object)a == (object)c); //輸出:False(“==”在兩邊為引用型別時,則比較引用的地址,所以a與b為不同引用)
//輸出:True (“==”在兩邊為引用型別時,則比較引用的地址,所以a與c的引用相同)(原文:ReferenceEquals比較字串物件的引用,a與c由於字串駐留機制,引用相同)

程式碼七:

string a = "str_1";
string c = "str_1";
Response.Write(a == c); //輸出:True(剛才我們提到過,“==”在兩邊為引用型別時,則比較引用的地址;如果是值型別時則需要比較引用和值。string為引用型別,那麼上面的程式碼是比較了變數a與c的地址還是地址和值呢?
       答案是:比較了地址和值!因為在string型別比較的時候,“==”已經被過載為“Equals”了,所以,雖然你在用“==”比較兩個引用型別,但實際上是在用“Equals”比較它們的地址和值!(先比較地址,地址不等再比較值))

程式碼八:

string a = "a";
string b = new string('a', );
Response.Write(a.Equals(b));
Response.Write(ReferenceEquals(a, b)); //輸出:True (Equals比較值,a與b的值相同)
//輸出:False(ReferenceEquals比較字串物件的引用)

程式碼九:

string a = "a";
string b = new string('a', );
Response.Write(a.Equals(string.Intern(b)));
Response.Write(ReferenceEquals(a, string.Intern(b)));
//輸出:True (Equals比較值,無論是否Intern都會相同)
//輸出:True (ReferenceEquals比較字串物件的引用,Intern已經將b駐留至字串池內)

程式碼十:

string a = "str";
string b = "str_2".Substring(,);
Response.Write(a.Equals(b));
Response.Write(ReferenceEquals(a, b));
//輸出:True (Equals比較值,a與c的值相同)
//輸出:False(ReferenceEquals比較字串物件的引用,Substring操作產生了新的字串物件)

四.藝海拾貝

  這一節將主要給大家介紹一些string的常見問題。

(1)“string = ”與“new stirng()”的區別

string test = "a";
string test = new string('a', );

  以上兩行程式碼的效果是一樣的,它們的區別在於載入”a”的時間不同:第一行的“a”是一個常量,在編譯期就已經被放在一個叫做常量池的地方了,常量池通常裝載一些在編譯期被確定下來的資料,例如類、介面等等;而第二行是執行時CLR在堆中生成的值為“a”的字串物件,所以後者沒有字串駐留。

(2). string 與 String的區別

  String的大名叫做System.String,在編譯為IL程式碼時,string和System.String會生成完全相同的程式碼:(ps:long和System.Int64,float和System.Single等也有此特性)

C#程式碼:

string str_test = "test";
System.String Str_test = "test";

IL程式碼:

// 程式碼大小       14 (0xe)
.maxstack
.locals init ([] string str_test,[] string Str_test)
IL_0000: nop
IL_0001: ldstr "test"
IL_0006: stloc.
IL_0007: ldstr "test"
IL_000c: stloc.
IL_000d: ret

  所以,二者的區別並不在於底層,而是在於string是類似於int的基元型別;System. String是框架類庫(FCL)的基本型別,二者之間有直接的對應關係。

(3).StringBuilder

  StringBuilder提供了高效建立字串的方法,由StringBuilder表示的字串是可變的(非恆定的),在需要多處使用“+”連線字串變數的時候,推薦使用StringBuilder來完成,最後呼叫其ToString()方法輸出。當呼叫了StringBuilder的ToString()方法之後,StringBuilder將返回其內部維護的一個字串欄位引用,如再次修改StringBuilder,它將會建立一個新的字串,這時被修改的是新的字串,原來已經返回的字串才不會發生改變。

StringBuilder有兩個比較重要的內部欄位,大家需要掌握:

  m_MaxCapacity:StringBuilder的最大容量,它規定了最多可以放置到        

  m_StringValue的字元個數,預設值為Int32.MaxValue。m_MaxCapacity一旦被指定就不能再更改。

  m_StringValue:StringBuilder維護的一個字元陣列串,實際上可以理解為一個字串。StringBuilder重寫的Tostring()方法返回的就是這個欄位。


相關文章:C# String與StringBuilder

C#擷取字串的方法小結

原文:http://www.cnblogs.com/isline/archive/2009/02/04/1383799.html