本文章是由機器翻譯。 將指標移到文章內的文字上方即可查看原文。 其他資訊。
譯文
原文
資訊
The topic you requested is included in another documentation set. For convenience, it's displayed below. Choose Switch to see the topic in its original location.

String 類別

將文字表示為一系列的 Unicode 字元。

命名空間:  System
組件:  mscorlib (在 mscorlib.dll 中)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public sealed class String : IComparable, 
	ICloneable, IConvertible, IComparable<string>, IEnumerable<char>, 
	IEnumerable, IEquatable<string>

String 類型會公開下列成員。

  名稱描述
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援String(Char*)String 類別的新執行個體初始化為 Unicode 字元陣列的指定指標所指示的值。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援String(Char[])String 類別的新執行個體初始化為 Unicode 字元陣列所指示的值。
公用方法受 XNA Framework 支援String(SByte*)String 類別的新執行個體初始化為 8 位元帶正負號整數 (Signed Integer) 陣列的指標所指示的值。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援String(Char, Int32)String 類別的新執行個體初始化為由重複指定次數的指定 Unicode 字元所指示的值。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援String(Char*, Int32, Int32)String 類別的新執行個體初始化為 Unicode 字元陣列、在陣列內起始字元的位置以及長度等等的指定指標所指示的值。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援String(Char[], Int32, Int32)String 類別的新執行個體初始化為 Unicode 字元陣列、在陣列內起始字元的位置和長度等等所指示的值。
公用方法String(SByte*, Int32, Int32)String 類別的新執行個體初始化為 8 位元帶正負號整數的陣列、在該陣列內起始位置和長度的指定指標所指示的值。
公用方法String(SByte*, Int32, Int32, Encoding)String 類別的新執行個體初始化為 8 位元帶正負號整數的陣列、在該陣列內起始位置、長度和 Encoding 物件的指定指標所指示的值。
回頁首

  名稱描述
公用屬性受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Chars取得目前 String 物件中指定位置的 Char 物件。
公用屬性受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Length取得目前 String 物件中字元的數目。
回頁首

  名稱描述
公用方法受 XNA Framework 支援Clone傳回對 String 這個執行個體的參考。
公用方法靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Compare(String, String)比較兩個指定的 String 物件,並傳回一個整數,指出它們在排序順序中的相對位置。
公用方法靜態成員受 XNA Framework 支援Compare(String, String, Boolean)比較兩個指定的 String 物件,忽略或區分兩者的大小寫,並傳回一個整數,表示兩者在排序順序中的相對位置。
公用方法靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Compare(String, String, StringComparison)使用指定的規則比較兩個指定的 String 物件,並傳回一個整數,表示兩者在排序順序中的相對位置。
公用方法靜態成員受 XNA Framework 支援Compare(String, String, Boolean, CultureInfo)比較兩個指定的 String 物件,忽略或區分兩者的大小寫,並使用文化特性資訊來影響比較,然後傳回一個整數,表示兩者在排序順序中的相對位置。
公用方法靜態成員受 可攜式類別庫 支援Compare(String, String, CultureInfo, CompareOptions)比較兩個指定的 String 物件,使用指定的比較選項及文化特性特定資訊影響比較,然後傳回整數,這個整數表示這兩個字串在排序次序中彼此的關聯性。
公用方法靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Compare(String, Int32, String, Int32, Int32)比較兩個指定的 String 物件的子字串,並傳回整數,這個整數表示兩者在排序次序中的相對位置。
公用方法靜態成員受 XNA Framework 支援Compare(String, Int32, String, Int32, Int32, Boolean)比較兩個指定之 String 物件的子字串,忽略或區分兩者的大小寫,並傳回一個整數,表示兩者在排序順序中的相對位置。
公用方法靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Compare(String, Int32, String, Int32, Int32, StringComparison)使用指定的規則比較兩個指定之 String 物件的子字串,並傳回一個整數,表示兩者在排序順序中的相對位置。
公用方法靜態成員受 XNA Framework 支援Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)比較兩個指定之 String 物件的子字串,忽略或區分兩者的大小寫,並使用文化特性資訊來影響比較,然後傳回一個整數,表示兩者在排序順序中的相對位置。
公用方法靜態成員Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)比較兩個指定的 String 物件的子字串,使用指定的比較選項及文化特性特定資訊影響比較,然後傳回整數,這個整數表示這兩個子字串在排序次序中彼此的關聯性。
公用方法靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援CompareOrdinal(String, String)藉由評估每個字串中對應的 Char 物件之數字值,比較兩個指定的 String 物件。
公用方法靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援CompareOrdinal(String, Int32, String, Int32, Int32)藉由評估每個子字串中對應的 Char 物件之數字值,比較兩個指定的 String 物件之子字串。
公用方法受 XNA Framework 支援CompareTo(Object)比較這個執行個體與指定的 Object,並且指出這個執行個體在排序次序中,位於所指定 Object 之前、之後或相同位置。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援CompareTo(String)比較這個執行個體與指定的 String 物件,並且指出這個執行個體在排序次序中,位於所指定 String 之前、之後或相同位置。
公用方法靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Concat(Object)建立指定之物件的字串表示。
公用方法靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Concat(Object[])串連指定之 Object 陣列中項目的字串表示法。
公用方法靜態成員受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Concat(IEnumerable<String>)串連型別 String 之已建構的 IEnumerable<T> 集合的成員。
公用方法靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Concat(String[])串連指定 String 陣列中的元素。
公用方法靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Concat(Object, Object)串連兩個指定之物件的字串表示。
公用方法靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Concat(String, String)串連 String 的兩個指定執行個體。
公用方法靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Concat(Object, Object, Object)串連三個指定之物件的字串表示。
公用方法靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Concat(String, String, String)串連 String 的三個指定執行個體。
公用方法靜態成員Concat(Object, Object, Object, Object)串連四個指定的物件之字串表示和選擇性變數長度參數清單中所指定的任何物件。
公用方法靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Concat(String, String, String, String)串連 String 的四個指定執行個體。
公用方法靜態成員受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Concat<T>(IEnumerable<T>)串連 IEnumerable<T> 實作的成員。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Contains傳回值,這個值表示指定的子字串是否會出現在這個字串內。
公用方法靜態成員受 XNA Framework 支援Copy使用與指定的 String 相同的值,建立 String 的新執行個體。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援CopyTo將字元的指定數目從這個執行個體的指定位置,複製到 Unicode 字元陣列的指定位置。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援EndsWith(String)判斷這個字串執行個體的結尾是否符合指定的字串。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援EndsWith(String, StringComparison)判斷當使用指定的比較選項進行比較時,這個字串執行個體的結尾是否符合指定的字串。
公用方法EndsWith(String, Boolean, CultureInfo)判斷當使用指定之文化特性進行比較時,這個字串執行個體的結尾是否符合指定的字串。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Equals(Object)判斷這個執行個體和指定的物件 (同時還必須是 String 物件) 是否具有相同的值。 (覆寫 Object.Equals(Object)。)
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Equals(String)判斷這個執行個體和另一個指定的 String 物件是否具有相同的值。
公用方法靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Equals(String, String)判斷兩個指定的 String 物件是否具有相同的值。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Equals(String, StringComparison)判斷這個字串和指定的 String 物件是否具有相同的值。 參數可指定用於比較的文化特性、大小寫及排序規則。
公用方法靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Equals(String, String, StringComparison)判斷兩個指定的 String 物件是否具有相同的值。 參數可指定用於比較的文化特性、大小寫及排序規則。
公用方法靜態成員受 XNA Framework 支援Format(String, Object)以指定之物件的字串表示,取代指定之字串中的一個或多個格式項目。
公用方法靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Format(String, Object[])以指定陣列中對應物件的字串表示,取代指定之字串中的格式項目。
公用方法靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Format(IFormatProvider, String, Object[])以指定陣列中對應物件的字串表示,取代指定之字串中的格式項目。 參數提供特定文化特性的格式資訊。
公用方法靜態成員受 XNA Framework 支援Format(String, Object, Object)以兩個指定之物件的字串表示,取代指定之字串中的格式項目。
公用方法靜態成員受 XNA Framework 支援Format(String, Object, Object, Object)以三個指定之物件的字串表示,取代指定之字串中的格式項目。
公用方法受 XNA Framework 支援GetEnumerator擷取可以逐一查看這個字串中個別字元的物件。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援GetHashCode傳回這個字串的雜湊碼。 (覆寫 Object.GetHashCode()。)
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援GetType取得目前執行個體的 Type (繼承自 Object)。
公用方法受 XNA Framework 支援GetTypeCode傳回類別 StringTypeCode
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援IndexOf(Char)報告這個字串中指定之 Unicode 字元第一次出現時的所在索引 (以零起始)。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援IndexOf(String)回報這個執行個體中指定之字串第一次出現時的所在索引 (以零起始)。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援IndexOf(Char, Int32)報告這個字串中指定之 Unicode 字元第一次出現時的所在索引 (以零起始)。 搜尋從指定的字元位置開始。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援IndexOf(String, Int32)回報這個執行個體中指定之字串第一次出現時的所在索引 (以零起始)。 搜尋從指定的字元位置開始。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援IndexOf(String, StringComparison)報告目前 String 物件中指定之字串第一次出現時的所在索引 (以零起始)。 參數會指定要用於指定字串的搜尋類型。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援IndexOf(Char, Int32, Int32)報告這個執行個體中指定之字元第一次出現時的所在索引 (以零起始)。 搜尋從指定的字元位置開始,並檢視指定數目的字元位置。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援IndexOf(String, Int32, Int32)回報這個執行個體中指定之字串第一次出現時的所在索引 (以零起始)。 搜尋從指定的字元位置開始,並檢視指定數目的字元位置。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援IndexOf(String, Int32, StringComparison)報告目前 String 物件中指定之字串第一次出現時的所在索引 (以零起始)。 參數會指定目前字串中的開始搜尋位置和要用於指定字串的搜尋類型。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援IndexOf(String, Int32, Int32, StringComparison)報告目前 String 物件中指定之字串第一次出現時的所在索引 (以零起始)。 參數會指定目前字串中的開始搜尋位置、目前字串中要搜尋的字元數目,以及要用於指定字串的搜尋類型。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援IndexOfAny(Char[])報告指定的 Unicode 字元陣列中,任何字元在這個執行個體中第一次出現時的所在索引 (以零起始)。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援IndexOfAny(Char[], Int32)報告指定的 Unicode 字元陣列中,任何字元在這個執行個體中第一次出現時的所在索引 (以零起始)。 搜尋從指定的字元位置開始。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援IndexOfAny(Char[], Int32, Int32)報告指定的 Unicode 字元陣列中,任何字元在這個執行個體中第一次出現時的所在索引 (以零起始)。 搜尋從指定的字元位置開始,並檢視指定數目的字元位置。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Insert傳回新字串,其中已在這個執行個體中指定的索引位置插入指定的字串。
公用方法靜態成員受 XNA Framework 支援Intern擷取指定的 String 的系統參考。
公用方法靜態成員受 XNA Framework 支援IsInterned擷取對指定 String 的參考。
公用方法IsNormalized()指出這個字串是否為 Unicode 正規化格式 C。
公用方法IsNormalized(NormalizationForm)指出這個字串是否為指定的 Unicode 正規化格式。
公用方法靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援IsNullOrEmpty表示指定的字串是否為 nullEmpty 字串。
公用方法靜態成員受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援IsNullOrWhiteSpace表示指定的字串是否為 null、空白,或只由空白字元組成的字串。
公用方法靜態成員受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Join(String, IEnumerable<String>)串連型別 String 之已建構的 IEnumerable<T> 集合的成員,並在每個成員之間使用指定的分隔符號。
公用方法靜態成員受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Join(String, Object[])串連物件陣列的元素,並在每個元素之間使用指定的分隔符號。
公用方法靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Join(String, String[])串連字串陣列的所有元素,並在每個元素之間使用指定的分隔符號。
公用方法靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Join(String, String[], Int32, Int32)串連字串陣列的指定元素,並在每個元素之間使用指定的分隔符號。
公用方法靜態成員受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Join<T>(String, IEnumerable<T>)串連集合的成員,並在每個成員之間使用指定的分隔符號。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援LastIndexOf(Char)報告這個執行個體中指定之 Unicode 字元最後一次出現時的所在索引 (以零起始)。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援LastIndexOf(String)回報這個執行個體中指定之字串最後一次出現時的所在索引 (以零起始)。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援LastIndexOf(Char, Int32)報告這個執行個體中指定之 Unicode 字元最後一次出現時的所在索引 (以零起始)。 搜尋會從指定的字元位置開始,然後反向朝字串的開頭進行。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援LastIndexOf(String, Int32)回報這個執行個體中指定之字串最後一次出現時的所在索引 (以零起始)。 搜尋會從指定的字元位置開始,然後反向朝字串的開頭進行。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援LastIndexOf(String, StringComparison)報告目前 String 物件中指定之字串最後一次出現時的所在索引 (以零起始)。 參數會指定要用於指定字串的搜尋類型。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援LastIndexOf(Char, Int32, Int32)報告這個執行個體的子字串中,指定的 Unicode 字元最後一次出現時的所在索引 (以零起始)。 搜尋會從指定的字元位置開始,然後反向朝字串開頭指定數目的字元位置繼續。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援LastIndexOf(String, Int32, Int32)回報這個執行個體中指定之字串最後一次出現時的所在索引 (以零起始)。 搜尋會從指定的字元位置開始,然後反向朝字串開頭指定數目的字元位置繼續。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援LastIndexOf(String, Int32, StringComparison)報告目前 String 物件中指定之字串最後一次出現時的所在索引 (以零起始)。 搜尋會從指定的字元位置開始,然後反向朝字串的開頭進行。 參數會指定搜尋指定字串時要執行的比較類型。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援LastIndexOf(String, Int32, Int32, StringComparison)回報這個執行個體中指定之字串最後一次出現時的所在索引 (以零起始)。 搜尋 starts at a specified character position 和 proceeds backward toward the beginning of the string for the specified number of character positions. 參數會指定搜尋指定字串時要執行的比較類型。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援LastIndexOfAny(Char[])報告 Unicode 陣列中的一個或多個指定的字元,在這個執行個體中最後一次出現時的所在索引 (以零起始)。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援LastIndexOfAny(Char[], Int32)報告 Unicode 陣列中的一個或多個指定的字元,在這個執行個體中最後一次出現時的所在索引 (以零起始)。 搜尋會從指定的字元位置開始,然後反向朝字串的開頭進行。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援LastIndexOfAny(Char[], Int32, Int32)報告 Unicode 陣列中的一個或多個指定的字元,在這個執行個體中最後一次出現時的所在索引 (以零起始)。 搜尋會從指定的字元位置開始,然後反向朝字串開頭指定數目的字元位置繼續。
公用方法Normalize()傳回新的字串,其文字值與這個字串相同,但是其二進位表示為 Unicode 正規化格式 C。
公用方法Normalize(NormalizationForm)傳回新的字串,其文字值與這個字串相同,但是其二進位表示為特定的 Unicode 正規化格式。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援PadLeft(Int32)傳回新字串,此字串會以空格填補左側至指定的總長度,靠右對齊這個執行個體中的字元。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援PadLeft(Int32, Char)傳回新字串,此字串會以指定的 Unicode 字元填補左側至指定的總長度,靠右對齊這個執行個體中的字元。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援PadRight(Int32)傳回新字串,此字串會以空格填補右側至指定的總長度,靠左對齊這個字串中的字元。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援PadRight(Int32, Char)傳回新字串,此字串會以指定的 Unicode 字元填補右側至指定的總長度,靠左對齊這個字串中的字元。
公用方法受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Remove(Int32)傳回新字串,其中已刪除目前執行個體中的所有字元 (從指定位置開始到最後一個位置為止)。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Remove(Int32, Int32)傳回新字串,其中已刪除在目前執行個體中指定位置開始之指定數目的字元。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Replace(Char, Char)傳回新字串,其中這個執行個體中所有出現的指定 Unicode 字元都取代成其他指定的 Unicode 字元。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Replace(String, String)傳回新字串,其中目前執行個體中所有出現的指定字串,都取代成其他指定的字串。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Split(Char[])傳回字串陣列,這個陣列包含這個執行個體中,由指定的 Unicode 字元陣列之元素所分隔的子字串。
公用方法受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Split(Char[], Int32)傳回字串陣列,這個陣列包含這個執行個體中,由指定的 Unicode 字元陣列之元素所分隔的子字串。 參數可指定要傳回的子字串數目的最大值。
公用方法受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Split(Char[], StringSplitOptions)傳回字串陣列,這個陣列包含這個字串中,由指定的 Unicode 字元陣列之元素所分隔的子字串。 參數指定是否傳回空白的陣列元素。
公用方法受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Split(String[], StringSplitOptions)傳回字串陣列,這個陣列包含這個字串中,由指定的字串陣列之元素所分隔的子字串。 參數指定是否傳回空白的陣列元素。
公用方法受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Split(Char[], Int32, StringSplitOptions)傳回字串陣列,這個陣列包含這個字串中,由指定的 Unicode 字元陣列之元素所分隔的子字串。 參數指定傳回的子字串最大數目,以及是否傳回空的陣列元素。
公用方法受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Split(String[], Int32, StringSplitOptions)傳回字串陣列,這個陣列包含這個字串中,由指定的字串陣列之元素所分隔的子字串。 參數指定傳回的子字串最大數目,以及是否傳回空的陣列元素。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援StartsWith(String)判斷這個字串執行個體的開頭是否符合指定的字串。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援StartsWith(String, StringComparison)判斷當使用指定之比較選項進行比較時,這個字串執行個體的開頭是否符合指定的字串。
公用方法StartsWith(String, Boolean, CultureInfo)判斷當使用指定之文化特性進行比較時,這個字串執行個體的開頭是否符合指定的字串。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Substring(Int32)從這個執行個體擷取子字串。 子字串會在指定的字元位置開始並繼續到字串的結尾。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Substring(Int32, Int32)從這個執行個體擷取子字串。 子字串起始於指定的字元位置,並且具有指定的長度。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援ToCharArray()將這個執行個體中的字元複製到 Unicode 字元陣列中。
公用方法受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援ToCharArray(Int32, Int32)將這個執行個體的指定子字串字元複製到 Unicode 字元陣列。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援ToLower()傳回此字串轉換為小寫的版本。
公用方法受 XNA Framework 支援ToLower(CultureInfo)使用指定之文化特性的大小寫規則,傳回這個字串轉換成小寫的複本。
公用方法受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援ToLowerInvariant傳回轉換成小寫的這個 String 物件之複本,透過的方式是使用不因文化特性而異的大小寫規則。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援ToString()傳回這個 String 的執行個體;不會執行實際的轉換。 (覆寫 Object.ToString()。)
公用方法受 XNA Framework 支援ToString(IFormatProvider)傳回這個 String 的執行個體;不會執行實際的轉換。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援ToUpper()傳回此字串轉換為大寫的版本。
公用方法受 XNA Framework 支援ToUpper(CultureInfo)使用指定之文化特性的大小寫規則,傳回這個字串轉換成大寫的複本。
公用方法受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援ToUpperInvariant傳回轉換成大寫的這個 String 物件之複本,透過的方式是使用不因文化特性而異的大小寫規則。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Trim()從目前的 String 物件中移除所有的前置和後端空白字元。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Trim(Char[])從目前的 String 物件中移除陣列中指定之一組字元的所有前置和後端指定項目。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援TrimEnd從目前的 String 物件中移除陣列中指定之一組字元的所有後端指定項目。
公用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援TrimStart從目前的 String 物件中移除陣列中指定之一組字元的所有前置指定項目。
回頁首

  名稱描述
公用運算子靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Equality判斷兩個指定的字串是否具有相同的值。
公用運算子靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Inequality判斷兩個指定的字串是否具有不同的值。
回頁首

  名稱描述
公用擴充方法受 XNA Framework 支援Aggregate<Char>(Func<Char, Char, Char>)多載。 將累加函式套用到序列上。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Aggregate<Char, TAccumulate>(TAccumulate, Func<TAccumulate, Char, TAccumulate>)多載。 將累加函式套用到序列上。 使用指定的初始值做為初始累加值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Aggregate<Char, TAccumulate, TResult>(TAccumulate, Func<TAccumulate, Char, TAccumulate>, Func<TAccumulate, TResult>)多載。 將累加函式套用到序列上。 使用指定的值做為初始累加值,並使用指定的函式來選取結果值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援All<Char>判斷序列的所有項目是否全都符合條件。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Any<Char>()多載。 判斷序列是否包含任何項目。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Any<Char>(Func<Char, Boolean>)多載。 判斷序列的任何項目是否符合條件。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援AsEnumerable<Char>傳回型別為 IEnumerable<T> 的輸入。 (以 Enumerable 定義。)
公用擴充方法受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援AsParallel()多載。 啟用查詢的平行化作業。 (以 ParallelEnumerable 定義。)
公用擴充方法AsParallel<Char>()多載。 啟用查詢的平行化作業。 (以 ParallelEnumerable 定義。)
公用擴充方法受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援AsQueryable()多載。 IEnumerable 轉換成 IQueryable (以 Queryable 定義。)
公用擴充方法AsQueryable<Char>()多載。 將泛型 IEnumerable<T> 轉換成泛型 IQueryable<T> (以 Queryable 定義。)
公用擴充方法受 XNA Framework 支援Average<Char>(Func<Char, Int32>)多載。 計算在輸入序列中各項目上叫用轉換函式後所取得之 Int32 值序列的平均值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Average<Char>(Func<Char, Nullable<Int32>>)多載。 計算在輸入序列中各項目上叫用轉換函式後所取得可為 Null 之 Int32 值的平均值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Average<Char>(Func<Char, Int64>)多載。 計算在輸入序列中各項目上叫用轉換函式後所取得之 Int64 值序列的平均值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Average<Char>(Func<Char, Nullable<Int64>>)多載。 計算在輸入序列中各項目上叫用轉換函式後所取得可為 Null 之 Int64 值的平均值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Average<Char>(Func<Char, Single>)多載。 計算在輸入序列中各項目上叫用轉換函式後所取得之 Single 值序列的平均值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Average<Char>(Func<Char, Nullable<Single>>)多載。 計算在輸入序列中各項目上叫用轉換函式後所取得可為 Null 之 Single 值的平均值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Average<Char>(Func<Char, Double>)多載。 計算在輸入序列中各項目上叫用轉換函式後所取得之 Double 值序列的平均值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Average<Char>(Func<Char, Nullable<Double>>)多載。 計算在輸入序列中各項目上叫用轉換函式後所取得可為 Null 之 Double 值的平均值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Average<Char>(Func<Char, Decimal>)多載。 計算在輸入序列中各項目上叫用轉換函式後所取得之 Decimal 值序列的平均值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Average<Char>(Func<Char, Nullable<Decimal>>)多載。 計算在輸入序列中各項目上叫用轉換函式後所取得可為 Null 之 Decimal 值的平均值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Cast<TResult>IEnumerable 的項目轉換成指定的型別。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Concat<Char>串連兩個序列。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Contains<Char>(Char)多載。 使用預設的相等比較子 (Comparer) 來判斷序列是否包含指定的項目。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Contains<Char>(Char, IEqualityComparer<Char>)多載。 使用指定的 IEqualityComparer<T> 來判斷序列是否包含指定的項目。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Count<Char>()多載。 傳回序列中的項目數。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Count<Char>(Func<Char, Boolean>)多載。 傳回數字,代表指定之序列中符合條件的項目數目。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援DefaultIfEmpty<Char>()多載。 傳回指定之序列的項目;如果序列是空的,則傳回單一集合中型別參數的預設值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援DefaultIfEmpty<Char>(Char)多載。 傳回指定之序列的項目;如果序列是空的,則傳回單一集合中型別參數的預設值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Distinct<Char>()多載。 使用預設的相等比較子來比較值,以便從序列傳回獨特的項目。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Distinct<Char>(IEqualityComparer<Char>)多載。 使用指定的 IEqualityComparer<T> 來比較值,以便從序列傳回獨特的項目。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援ElementAt<Char>傳回位於序列中指定索引處的項目。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援ElementAtOrDefault<Char>傳回位於序列中指定索引處的項目;如果索引超出範圍,則傳回預設值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Except<Char>(IEnumerable<Char>)多載。 使用預設相等比較子來比較值,以便產生兩個序列的差異。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Except<Char>(IEnumerable<Char>, IEqualityComparer<Char>)多載。 使用指定的 IEqualityComparer<T> 來比較值,以便產生兩個序列的差異。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援First<Char>()多載。 傳回序列的第一個項目。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援First<Char>(Func<Char, Boolean>)多載。 傳回序列中符合指定之條件的第一個項目。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援FirstOrDefault<Char>()多載。 傳回序列的第一個項目;如果序列中沒有包含任何項目,則傳回預設值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援FirstOrDefault<Char>(Func<Char, Boolean>)多載。 傳回序列中符合條件的第一個項目;如果找不到這類項目,則傳回預設值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援GroupBy<Char, TKey>(Func<Char, TKey>)多載。 依據指定的索引鍵選擇器函式來群組序列的項目。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援GroupBy<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)多載。 依據指定的索引鍵選取器函式來群組序列的項目,並使用指定的比較子來比較索引鍵。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援GroupBy<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)多載。 依據指定的索引鍵選取器函式來群組序列的項目,並使用指定的函式來投影每個群組的項目。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援GroupBy<Char, TKey, TResult>(Func<Char, TKey>, Func<TKey, IEnumerable<Char>, TResult>)多載。 依據指定的索引鍵選取器函式來群組序列的項目,並從每個群組及其索引鍵建立結果值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援GroupBy<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)多載。 依據索引鍵選取器函式來群組序列中的項目。 索引鍵是使用比較子來進行比較,而每個群組的項目都是利用指定的函式進行投影。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援GroupBy<Char, TKey, TResult>(Func<Char, TKey>, Func<TKey, IEnumerable<Char>, TResult>, IEqualityComparer<TKey>)多載。 依據指定的索引鍵選取器函式來群組序列的項目,並從每個群組及其索引鍵建立結果值。 索引鍵是使用指定的比較子來進行比較。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援GroupBy<Char, TKey, TElement, TResult>(Func<Char, TKey>, Func<Char, TElement>, Func<TKey, IEnumerable<TElement>, TResult>)多載。 依據指定的索引鍵選取器函式來群組序列的項目,並從每個群組及其索引鍵建立結果值。 每個群組的項目都是利用指定的函式進行投影。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援GroupBy<Char, TKey, TElement, TResult>(Func<Char, TKey>, Func<Char, TElement>, Func<TKey, IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)多載。 依據指定的索引鍵選取器函式來群組序列的項目,並從每個群組及其索引鍵建立結果值。 索引鍵值是使用指定的比較子來進行比較,而每個群組的項目則都是利用指定的函式進行投影。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援GroupJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, IEnumerable<TInner>, TResult>)多載。 根據索引鍵相等與否,將兩個序列的項目相互關聯,並群組產生的結果。 預設的相等比較子是用於比較索引鍵。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援GroupJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)多載。 根據索引鍵相等與否,將兩個序列的項目相互關聯,並群組產生的結果。 指定的 IEqualityComparer<T> 是用於比較索引鍵。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Intersect<Char>(IEnumerable<Char>)多載。 使用預設相等比較子來比較值,以便產生兩個序列的交集。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Intersect<Char>(IEnumerable<Char>, IEqualityComparer<Char>)多載。 使用指定的 IEqualityComparer<T> 來比較值,以便產生兩個序列的交集。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Join<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, TInner, TResult>)多載。 根據相符索引鍵,將兩個序列的項目相互關聯。 預設的相等比較子是用於比較索引鍵。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Join<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, TInner, TResult>, IEqualityComparer<TKey>)多載。 根據相符索引鍵,將兩個序列的項目相互關聯。 指定的 IEqualityComparer<T> 是用於比較索引鍵。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Last<Char>()多載。 傳回序列的最後一個項目。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Last<Char>(Func<Char, Boolean>)多載。 傳回序列中符合指定之條件的最後一個項目。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援LastOrDefault<Char>()多載。 傳回序列的最後一個項目;如果序列中沒有包含任何項目,則傳回預設值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援LastOrDefault<Char>(Func<Char, Boolean>)多載。 傳回序列中符合條件的最後一個項目;如果找不到這類項目,則傳回預設值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援LongCount<Char>()多載。 傳回代表序列中項目總數的 Int64 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援LongCount<Char>(Func<Char, Boolean>)多載。 傳回 Int64,其代表序列中符合條件的項目數目。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Max<Char>()多載。 傳回泛型序列中的最大值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Max<Char>(Func<Char, Int32>)多載。 在序列的每個項目上叫用轉換函式,並傳回最大的 Int32 值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Max<Char>(Func<Char, Nullable<Int32>>)多載。 在序列的每個項目上叫用轉換函式,並傳回最大的可為 Null 之 Int32 值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Max<Char>(Func<Char, Int64>)多載。 在序列的每個項目上叫用轉換函式,並傳回最大的 Int64 值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Max<Char>(Func<Char, Nullable<Int64>>)多載。 在序列的每個項目上叫用轉換函式,並傳回最大的可為 Null 之 Int64 值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Max<Char>(Func<Char, Single>)多載。 在序列的每個項目上叫用轉換函式,並傳回最大的 Single 值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Max<Char>(Func<Char, Nullable<Single>>)多載。 在序列的每個項目上叫用轉換函式,並傳回最大的可為 Null 之 Single 值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Max<Char>(Func<Char, Double>)多載。 在序列的每個項目上叫用轉換函式,並傳回最大的 Double 值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Max<Char>(Func<Char, Nullable<Double>>)多載。 在序列的每個項目上叫用轉換函式,並傳回最大的可為 Null 之 Double 值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Max<Char>(Func<Char, Decimal>)多載。 在序列的每個項目上叫用轉換函式,並傳回最大的 Decimal 值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Max<Char>(Func<Char, Nullable<Decimal>>)多載。 在序列的每個項目上叫用轉換函式,並傳回最大的可為 Null 之 Decimal 值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Max<Char, TResult>(Func<Char, TResult>)多載。 在泛型序列的每個項目上叫用轉換函式,並傳回最大的結果值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Min<Char>()多載。 傳回泛型序列中的最小值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Min<Char>(Func<Char, Int32>)多載。 在序列的每個項目上叫用轉換函式,並傳回最小的 Int32 值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Min<Char>(Func<Char, Nullable<Int32>>)多載。 在序列的每個項目上叫用轉換函式,並傳回最小的可為 Null 之 Int32 值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Min<Char>(Func<Char, Int64>)多載。 在序列的每個項目上叫用轉換函式,並傳回最小的 Int64 值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Min<Char>(Func<Char, Nullable<Int64>>)多載。 在序列的每個項目上叫用轉換函式,並傳回最小的可為 Null 之 Int64 值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Min<Char>(Func<Char, Single>)多載。 在序列的每個項目上叫用轉換函式,並傳回最小的 Single 值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Min<Char>(Func<Char, Nullable<Single>>)多載。 在序列的每個項目上叫用轉換函式,並傳回最小的可為 Null 之 Single 值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Min<Char>(Func<Char, Double>)多載。 在序列的每個項目上叫用轉換函式,並傳回最小的 Double 值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Min<Char>(Func<Char, Nullable<Double>>)多載。 在序列的每個項目上叫用轉換函式,並傳回最小的可為 Null 之 Double 值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Min<Char>(Func<Char, Decimal>)多載。 在序列的每個項目上叫用轉換函式,並傳回最小的 Decimal 值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Min<Char>(Func<Char, Nullable<Decimal>>)多載。 在序列的每個項目上叫用轉換函式,並傳回最小的可為 Null 之 Decimal 值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Min<Char, TResult>(Func<Char, TResult>)多載。 在泛型序列的每個項目上叫用轉換函式,並傳回最小的結果值。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援OfType<TResult>根據指定的型別來篩選 IEnumerable 的項目。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援OrderBy<Char, TKey>(Func<Char, TKey>)多載。 依據索引鍵,按遞增順序排序序列中的項目。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援OrderBy<Char, TKey>(Func<Char, TKey>, IComparer<TKey>)多載。 使用指定的比較子,依遞增順序排序序列中的項目。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援OrderByDescending<Char, TKey>(Func<Char, TKey>)多載。 依據索引鍵,按遞減順序排序序列中的項目。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援OrderByDescending<Char, TKey>(Func<Char, TKey>, IComparer<TKey>)多載。 使用指定的比較子,依遞減順序排序序列中的項目。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Reverse<Char>反轉序列中項目的排序方向。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Select<Char, TResult>(Func<Char, TResult>)多載。 將序列的每一個項目規劃成一個新的表單。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Select<Char, TResult>(Func<Char, Int32, TResult>)多載。 透過加入項目的索引,將序列的每個項目投影成新的表單。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援SelectMany<Char, TResult>(Func<Char, IEnumerable<TResult>>)多載。 將序列的每個項目都投影成 IEnumerable<T>,並將產生的序列簡化成單一序列。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援SelectMany<Char, TResult>(Func<Char, Int32, IEnumerable<TResult>>)多載。 將序列的每個項目都投影成 IEnumerable<T>,並將產生的序列簡化成單一序列。 各來源項目的索引是在該項目的投影表單中使用。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援SelectMany<Char, TCollection, TResult>(Func<Char, Int32, IEnumerable<TCollection>>, Func<Char, TCollection, TResult>)多載。 將序列的每個項目投影為 IEnumerable<T>、將產生的序列簡化成單一序列,並對其中的每個項目叫用結果選取器函式。 各來源項目的索引是在該項目的中繼投影表單中使用。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援SelectMany<Char, TCollection, TResult>(Func<Char, IEnumerable<TCollection>>, Func<Char, TCollection, TResult>)多載。 將序列的每個項目投影為 IEnumerable<T>、將產生的序列簡化成單一序列,並對其中的每個項目叫用結果選取器函式。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援SequenceEqual<Char>(IEnumerable<Char>)多載。 使用項目之型別的預設相等比較子來比較項目,以判斷兩個序列是否相等。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援SequenceEqual<Char>(IEnumerable<Char>, IEqualityComparer<Char>)多載。 使用指定的 IEqualityComparer<T> 來比較項目,以判斷兩個序列是否相等。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Single<Char>()多載。 傳回序列的唯一一個項目,如果序列中不是正好一個項目,則擲回例外狀況。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Single<Char>(Func<Char, Boolean>)多載。 傳回序列中符合指定之條件的唯一一個項目,如果有一個以上這類項目,則擲回例外狀況。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援SingleOrDefault<Char>()多載。 傳回序列的唯一一個項目,如果序列是空白,則為預設值,如果序列中有一個以上的項目,這個方法就會擲回例外狀況。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援SingleOrDefault<Char>(Func<Char, Boolean>)多載。 傳回序列中符合指定之條件的唯一一個項目,如果沒有這類項目,則為預設值,如果有一個以上的項目符合條件,這個方法就會擲回例外狀況。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Skip<Char>略過序列中指定的項目數目,然後傳回其餘項目。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援SkipWhile<Char>(Func<Char, Boolean>)多載。 只要指定的條件為 true,便略過序列中的項目,然後傳回其餘項目。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援SkipWhile<Char>(Func<Char, Int32, Boolean>)多載。 只要指定的條件為 true,便略過序列中的項目,然後傳回其餘項目。 項目的索引是用於述詞功能的邏輯中。 (以 Enumerable 定義。)
公用擴充方法Subscribe<Char>(IObserver<Char>)多載。 (以 Observable 定義。)
公用擴充方法Subscribe<Char>(IObserver<Char>, IScheduler)多載。 (以 Observable 定義。)
公用擴充方法受 XNA Framework 支援Sum<Char>(Func<Char, Int32>)多載。 計算在輸入序列中各項目上叫用轉換函式後所取得之 Int32 值序列的總和。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Sum<Char>(Func<Char, Nullable<Int32>>)多載。 計算在輸入序列中各項目上叫用轉換函式後所取得可為 Null 之 Int32 值的總和。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Sum<Char>(Func<Char, Int64>)多載。 計算在輸入序列中各項目上叫用轉換函式後所取得之 Int64 值序列的總和。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Sum<Char>(Func<Char, Nullable<Int64>>)多載。 計算在輸入序列中各項目上叫用轉換函式後所取得可為 Null 之 Int64 值的總和。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Sum<Char>(Func<Char, Single>)多載。 計算在輸入序列中各項目上叫用轉換函式後所取得之 Single 值序列的總和。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Sum<Char>(Func<Char, Nullable<Single>>)多載。 計算在輸入序列中各項目上叫用轉換函式後所取得可為 Null 之 Single 值的總和。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Sum<Char>(Func<Char, Double>)多載。 計算在輸入序列中各項目上叫用轉換函式後所取得之 Double 值序列的總和。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Sum<Char>(Func<Char, Nullable<Double>>)多載。 計算在輸入序列中各項目上叫用轉換函式後所取得可為 Null 之 Double 值的總和。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Sum<Char>(Func<Char, Decimal>)多載。 計算在輸入序列中各項目上叫用轉換函式後所取得之 Decimal 值序列的總和。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Sum<Char>(Func<Char, Nullable<Decimal>>)多載。 計算在輸入序列中各項目上叫用轉換函式後所取得可為 Null 之 Decimal 值的總和。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Take<Char>從序列開頭傳回指定的連續項目數目。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援TakeWhile<Char>(Func<Char, Boolean>)多載。 只要指定的條件為 true,就會傳回序列中的項目。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援TakeWhile<Char>(Func<Char, Int32, Boolean>)多載。 只要指定的條件為 true,就會傳回序列中的項目。 項目的索引是用於述詞功能的邏輯中。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援ToArray<Char>IEnumerable<T> 建立陣列。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援ToDictionary<Char, TKey>(Func<Char, TKey>)多載。 根據指定的索引鍵選擇器函式,從 IEnumerable<T> 建立 Dictionary<TKey, TValue> (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援ToDictionary<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)多載。 根據指定的索引鍵選取器函式和索引鍵比較子,從 IEnumerable<T> 建立 Dictionary<TKey, TValue> (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援ToDictionary<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)多載。 根據指定的索引鍵選取器和項目選取器函式,從 IEnumerable<T> 建立 Dictionary<TKey, TValue> (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援ToDictionary<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)多載。 根據指定的索引鍵選取器函式、比較子和項目選取器函式,從 IEnumerable<T> 建立 Dictionary<TKey, TValue> (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援ToList<Char>IEnumerable<T> 建立 List<T> (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援ToLookup<Char, TKey>(Func<Char, TKey>)多載。 根據指定的索引鍵選擇器函式,從 IEnumerable<T> 建立 Lookup<TKey, TElement> (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援ToLookup<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)多載。 根據指定的索引鍵選取器函式和索引鍵比較子,從 IEnumerable<T> 建立 Lookup<TKey, TElement> (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援ToLookup<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)多載。 根據指定的索引鍵選取器和項目選取器函式,從 IEnumerable<T> 建立 Lookup<TKey, TElement> (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援ToLookup<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)多載。 根據指定的索引鍵選取器函式、比較子和項目選取器函式,從 IEnumerable<T> 建立 Lookup<TKey, TElement> (以 Enumerable 定義。)
公用擴充方法ToObservable<Char>()多載。 (以 Observable 定義。)
公用擴充方法ToObservable<Char>(IScheduler)多載。 (以 Observable 定義。)
公用擴充方法受 XNA Framework 支援Union<Char>(IEnumerable<Char>)多載。 使用預設相等比較值來比較值,以便產生兩個序列的集合等位。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Union<Char>(IEnumerable<Char>, IEqualityComparer<Char>)多載。 使用指定的 IEqualityComparer<T> 產生兩個序列的集合等位。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Where<Char>(Func<Char, Boolean>)多載。 根據述詞來篩選值序列。 (以 Enumerable 定義。)
公用擴充方法受 XNA Framework 支援Where<Char>(Func<Char, Int32, Boolean>)多載。 根據述詞來篩選值序列。 述詞函式的邏輯中使用各項目的索引。 (以 Enumerable 定義。)
公用擴充方法Zip<Char, TSecond, TResult>將指定的函式套用至兩個序列的對應項目,產生結果的序列。 (以 Enumerable 定義。)
回頁首

  名稱描述
公用欄位靜態成員受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援Empty表示空字串。 這個欄位是唯讀的。
回頁首

  名稱描述
明確介面實作私用方法受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援IComparable.CompareTo將目前的執行個體與相同型別的另一個物件相比較,並傳回整數,這個整數表示目前的執行個體在排序次序中,位於另一個物件之前、之後或相同位置。
明確介面實作私用方法受 XNA Framework 支援IConvertible.ToBoolean基礎架構。如需這個成員的描述,請參閱 ToBoolean
明確介面實作私用方法受 XNA Framework 支援IConvertible.ToByte基礎架構。如需這個成員的描述,請參閱 ToByte
明確介面實作私用方法受 XNA Framework 支援IConvertible.ToChar基礎架構。如需這個成員的描述,請參閱 ToChar
明確介面實作私用方法受 XNA Framework 支援IConvertible.ToDateTime基礎架構。如需這個成員的描述,請參閱 ToDateTime
明確介面實作私用方法受 XNA Framework 支援IConvertible.ToDecimal基礎架構。如需這個成員的描述,請參閱 ToDecimal
明確介面實作私用方法受 XNA Framework 支援IConvertible.ToDouble基礎架構。如需這個成員的描述,請參閱 ToDouble
明確介面實作私用方法受 XNA Framework 支援IConvertible.ToInt16基礎架構。如需這個成員的描述,請參閱 ToInt16
明確介面實作私用方法受 XNA Framework 支援IConvertible.ToInt32基礎架構。如需這個成員的描述,請參閱 ToInt32
明確介面實作私用方法受 XNA Framework 支援IConvertible.ToInt64基礎架構。如需這個成員的描述,請參閱 ToInt64
明確介面實作私用方法受 XNA Framework 支援IConvertible.ToSByte基礎架構。如需這個成員的描述,請參閱 ToSByte
明確介面實作私用方法受 XNA Framework 支援IConvertible.ToSingle基礎架構。如需這個成員的描述,請參閱 ToSingle
明確介面實作私用方法受 XNA Framework 支援IConvertible.ToType基礎架構。如需這個成員的描述,請參閱 ToType
明確介面實作私用方法受 XNA Framework 支援IConvertible.ToUInt16基礎架構。如需這個成員的描述,請參閱 ToUInt16
明確介面實作私用方法受 XNA Framework 支援IConvertible.ToUInt32基礎架構。如需這個成員的描述,請參閱 ToUInt32
明確介面實作私用方法受 XNA Framework 支援IConvertible.ToUInt64基礎架構。如需這個成員的描述,請參閱 ToUInt64
明確介面實作私用方法受 XNA Framework 支援IEnumerable<Char>.GetEnumerator傳回列舉值,可逐一查看目前的 String 物件。
明確介面實作私用方法受 XNA Framework 支援受 可攜式類別庫 支援適用於 Windows 市集應用程式的 .NET支援IEnumerable.GetEnumerator傳回列舉值,可逐一查看目前的 String 物件。
回頁首

字串是指用來表示文字的 Unicode 字元之循序集合。 String 物件是指表示字串的 System.Char 物件之循序集合。 String 物件的值是循序集合的內容,而該值為不可變 (即唯讀)。 如需字串不變性的相關資訊,請參閱此主題中的不變性與 StringBuilder 類別一節。 一個 String 物件的最大記憶體中是 2 GB 或大約 10 億個字元。

本節內容:

執行各體化字串物件
Char 物件和 Unicode 字元
字串和內嵌 Null 字元
字串和索引
Null 字串和空字串
不變性和 StringBuilder 類別
序數比較文化特性的作業。
正規化
依分類排列的字串作業

執行各體化字串物件

您可以透過下列方式具現化 String 物件:

  • 將字串常值指派給 String 變數。 這是最常用來建立字串的方法。 下列範例會使用指派,建立數個字串。 請注意,在 C# 中,因為反斜線 (\) 是逸出字元,因此必須將字串中的常值反斜線逸出,否則整個字串必須以 @ 括住。

    
    string string1 = "This is a string created by assignment.";
    Console.WriteLine(string1);
    string string2a = "The path is C:\\PublicDocuments\\Report1.doc";
    Console.WriteLine(string2a);
    string string2b = @"The path is C:\PublicDocuments\Report1.doc";
    Console.WriteLine(string2b);
    // The example displays the following output:
    //       This is a string created by assignment.
    //       The path is C:\PublicDocuments\Report1.doc
    //       The path is C:\PublicDocuments\Report1.doc      
    
    
    
  • 呼叫 String 類別建構函式。 下列範例會透過呼叫數個類別建構函式,具現化字串。 請注意,某些建構函式包含字元陣列或帶正副號位元組陣列的指標作為參數。 Visual Basic 不支援呼叫這些建構函式。 如需 String 建構函式的詳細資訊,請參閱 String 建構函式摘要。

    
    char[] chars = { 'w', 'o', 'r', 'd' };
    sbyte[] bytes = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };
    
    // Create a string from a character array.
    string string1 = new string(chars);
    Console.WriteLine(string1);
    
    // Create a string that consists of a character repeated 20 times.
    string string2 = new string('c', 20);
    Console.WriteLine(string2);
    
    string stringFromBytes = null;
    string stringFromChars = null;
    unsafe
    {
       fixed (sbyte* pbytes = bytes)
       {
          // Create a string from a pointer to a signed byte array.
          stringFromBytes = new string(pbytes);
       }
       fixed (char* pchars = chars)
       {
          // Create a string from a pointer to a character array.
          stringFromChars = new string(pchars);
       }
    }
    Console.WriteLine(stringFromBytes);
    Console.WriteLine(stringFromChars);
    // The example displays the following output:
    //       word
    //       cccccccccccccccccccc
    //       ABCDE
    //       word  
    
    
    
  • 使用字串串連運算子 (在 C# 中為+,在 Visual Basic 中為 & 或 +),從 String 執行個體和字串常值的任何組合建立單一字串。 下列範例說明字串串連運算子的用法。

    
    string string1 = "Today is " + DateTime.Now.ToString("D") + ".";
    Console.WriteLine(string1);
    
    string string2 = "This is one sentence. " + "This is a second. ";
    string2 += "This is a third sentence.";
    Console.WriteLine(string2);
    // The example displays output like the following:
    //    Today is Tuesday, July 06, 2011.
    //    This is one sentence. This is a second. This is a third sentence.
    
    
    
  • 擷取屬性,或呼叫傳回字串的方法。 下列範例使用 String 類別的方法,從較大的字串中擷取子字串。

    
    string sentence = "This sentence has five words.";
    // Extract the second word.
    int startPosition = sentence.IndexOf(" ") + 1;
    string word2 = sentence.Substring(startPosition,
                                      sentence.IndexOf(" ", startPosition) - startPosition);
    Console.WriteLine("Second word: " + word2);
    // The example displays the following output:
    //       Second word: sentence
    
    
    
  • 呼叫格式化方法將值或物件轉換為字串表示。 下列範例使用合成格式化功能,將兩個物件的字串表示內嵌在字串中。

    
    DateTime dateAndTime = new DateTime(2011, 7, 6, 7, 32, 0);
    double temperature = 68.3;
    string result = String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                  dateAndTime, temperature);
    Console.WriteLine(result);
    // The example displays the following output:
    //       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.      
    
    
    

Char 物件和 Unicode 字元

字串中的每個字元是由 Unicode 純量值所定義,也稱為 Unicode 字碼指標或 Unicode 字元的序數 (數字) 值。 每個字碼指標都是使用 UTF-16 編碼方式編碼,而編碼方式的每個項目之數值是由 Char 物件表示。

單一的 Char 物件通常表示單一的字碼指標,也就是說,Char 的數值等於字碼指標。 例如,字元 "a" 的字碼元素是 U+0061。 但是,字碼指標可能需要一個以上的編碼項目 (一個以上的 Char 物件)。 Unicode 標準定義了對應於多個 Char 物件的三種字元:字素 (Grapheme)、Unicode 補充字碼指標,以及輔助字面中的字元。

  • 字母 (Grapheme) 是由基底字元後面接著一個或多個組合字元所表示。 例如,字元 ä 是由 Char 物件 (字碼指標為 U+0061) 後面加上 Char 物件 (字碼指標為 U+0308) 來表示。 此字元也可以由字碼指標為 U+00E4 的單一 Char 物件來定義。 如下列範例所示,區分文化特性的相等比較指出儘管在一般序數比較上不相等,但這兩種表示是相等的。 但是,如果兩個字串均正常化,序號比較還表明它們相等。(如需正規化字串的詳細資訊,請參閱正規化一節)。

    
    using System;
    using System.Globalization;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\graphemes.txt");
          string grapheme = "\u0061\u0308";
          sw.WriteLine(grapheme);
    
          string singleChar = "\u00e4";
          sw.WriteLine(singleChar);
    
          sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.CurrentCulture));
          sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.Ordinal));
          sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme.Normalize(), 
                                     singleChar.Normalize(), 
                                     StringComparison.Ordinal));
          sw.Close(); 
       }
    }
    // The example produces the following output:
    //       ä
    //       ä
    //       ä = ä (Culture-sensitive): True
    //       ä = ä (Ordinal): False
    //       ä = ä (Normalized Ordinal): True
    
    
    
  • Unicode 補充字碼指標 (Surrogate 字組) 是以 Char 物件 (字碼指標為高 Surrogate) 後面接著 Char 物件 (字碼指標為低 Surrogate) 來表示。 高 Surrogate 字碼單元的範圍是從 U+D800 到 U+DBFF。 低 Surrogate 字碼單元的範圍是從 U+DC00 到 U+DFFF。 Surrogate 字組用於表示 16 個 Unicode 輔助字面中的字元。 下列範例會建立一個 Surrogate 字元,並將它傳遞給 Char.IsSurrogatePair(Char, Char) 方法以判斷它是否為 Surrogate 字組。

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          string surrogate = "\uD800\uDC03";
          for (int ctr = 0; ctr < surrogate.Length; ctr++) 
             Console.Write("U+{0:X2} ", Convert.ToUInt16(surrogate[ctr]));
    
          Console.WriteLine();
          Console.WriteLine("   Is Surrogate Pair: {0}", 
                            Char.IsSurrogatePair(surrogate[0], surrogate[1]));
       }
    }
    // The example displays the following output:
    //       U+D800 U+DC03
    //          Is Surrogate Pair: True
    
    
    

字串和內嵌 Null 字元

在 .NET Framework 中,String 物件可以包含內嵌的 null 字元,這些字元會視為字串長度的一部分。 不過,在某些語言 (例如 C 和 C++) 中,null 字元表示字串結尾,因此不會視為字串的一部分,也不會計算為字串長度的一部分。 這表示,C 和 C++ 程式設計人員或者以 C 或 C++ 撰寫的程式庫對字串的下列通用假設,在套用至 String 物件時,不一定是有效的:

  • strlen wcslen 函式所傳回的值不一定等於 String.Length

  • strcpy_s wcscpy_s 函式所建立的字串不一定與 String.Copy 方法所建立的字串相同。

您應確定具現化 String 物件的原生 C 和 C++ 程式碼 (以及透過平台叫用傳給它 String 物件的程式碼),請勿假設內嵌 Null 字元會標記字串的結尾。

排序字串及搜尋字串時,內嵌於字串中的 Null 字元也會以不同的方式處理。 在兩個字串之間執行區分文化特性的比較時會忽略 Null 字元,包括使用不因文化特性而異的比較。 他們只會被認定為序數或不區分大小寫的序數比較。 另一方面,使用方法 (例如 ContainsStartsWithIndexOf) 搜尋字串時,永遠會考量內嵌的 Null 字元。

字串和索引

String 中,索引是 Char 物件的位置 (而不是 Unicode 字元)。 索引是以零為起始的、非負值的數字,從字串的第一個位置開始,也就是索引位置零。 有些搜尋方法 (例如 IndexOfLastIndexOf) 會傳回字元或子字串在字串執行個體中的索引。

Chars 屬性可讓您依字串中的索引位置,存取個別的 Char 物件。 因為 Chars 屬性是預設屬性 (在 Visual Basic 中) 或索引子 (在 C# 中),您可以使用如下所示的程式碼存取字串中的個別 Char 物件。 此程式碼會在字串中尋找空白字元或標點字元,以判斷該字串包含多少字。


using System;

public class Example
{
   public static void Main()
   {
      string s1 = "This string consists of a single short sentence.";
      int nWords = 0;

      s1 = s1.Trim();      
      for (int ctr = 0; ctr < s1.Length; ctr++) {
         if (Char.IsPunctuation(s1[ctr]) | Char.IsWhiteSpace(s1[ctr]))
            nWords++;              
      }
      Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                        s1, nWords);                                                                     
   }
}
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.


因為 String 類別會實作 IEnumerable 介面,您也可以使用 foreach 建構逐一查看字串中的 Char 物件,如下列範例所示。


using System;

public class Example
{
   public static void Main()
   {
      string s1 = "This string consists of a single short sentence.";
      int nWords = 0;

      s1 = s1.Trim();      
      foreach (var ch in s1) {
         if (Char.IsPunctuation(ch) | Char.IsWhiteSpace(ch))
            nWords++;              
      }
      Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                        s1, nWords);                                                                     
   }
}
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.


連續的索引值可能不會對應到連續的 Unicode 字元,因為 Unicode 字元可能會編碼為一個以上的 Char 物件。 特別是,字串可能包含由 Surrogate 字組遵循中一個或多個組合字元或基底字元組成的文字多字元單位。 若要使用 Unicode 字元而不是 Char 物件,請使用 System.Globalization.StringInfoTextElementEnumerator 類別。 下列範例說明處理 Char 物件之程式碼和處理 Unicode 字元之程式碼之間的差異。 它會比較句子中每個字組的字元或文字元素數目。 該字串包含基底字元的兩個序列,後面接著組合字元。


using System;
using System.Collections.Generic;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // First sentence of The Mystery of the Yellow Room, by Leroux.
      string opening = "Ce n'est pas sans une certaine émotion que "+
                       "je commence à raconter ici les aventures " +
                       "extraordinaires de Joseph Rouletabille."; 
      // Character counters.
      int nChars = 0;
      // Objects to store word count.
      List<int> chars = new List<int>();
      List<int> elements = new List<int>();

      foreach (var ch in opening) {
         // Skip the ' character.
         if (ch == '\u0027') continue;

         if (Char.IsWhiteSpace(ch) | (Char.IsPunctuation(ch))) {
            chars.Add(nChars);
            nChars = 0;
         }
         else {
            nChars++;
         }
      }

      TextElementEnumerator te = StringInfo.GetTextElementEnumerator(opening);
      while (te.MoveNext()) {
         string s = te.GetTextElement();   
         // Skip the ' character.
         if (s == "\u0027") continue;
         if ( String.IsNullOrEmpty(s.Trim()) | (s.Length == 1 && Char.IsPunctuation(Convert.ToChar(s)))) {
            elements.Add(nChars);         
            nChars = 0;
         }
         else {
            nChars++;
         }
      }

      // Display character counts.
      Console.WriteLine("{0,6} {1,20} {2,20}",
                        "Word #", "Char Objects", "Characters"); 
      for (int ctr = 0; ctr < chars.Count; ctr++) 
         Console.WriteLine("{0,6} {1,20} {2,20}",
                           ctr, chars[ctr], elements[ctr]); 
   }
}
// The example displays the following output:
//       Word #         Char Objects           Characters
//            0                    2                    2
//            1                    4                    4
//            2                    3                    3
//            3                    4                    4
//            4                    3                    3
//            5                    8                    8
//            6                    8                    7
//            7                    3                    3
//            8                    2                    2
//            9                    8                    8
//           10                    2                    1
//           11                    8                    8
//           12                    3                    3
//           13                    3                    3
//           14                    9                    9
//           15                   15                   15
//           16                    2                    2
//           17                    6                    6
//           18                   12                   12


這個範例與文字項目一起以 StringInfo.GetTextElementEnumerator 方法和 TextElementEnumerator 類別使用來列舉字串中的所有文字項目。 您也可以擷取呼叫 StringInfo.ParseCombiningCharacters 方法中每個文字項目開始的索引陣列。

如需處理文字時使用單位的更多資訊而不是個別的 Char 值,請參閱 StringInfo 類別。

Null 字串和空字串

已宣告但尚未指派值的字串會是 null 嘗試對該字串呼叫方法會擲回 NullReferenceException Null 字串與空字串不同,後者是值為 "" 或 String.Empty 的字串。 在某些情況下,在方法中以引述傳遞 Null 字串或空字串會擲回例外狀況。 例如,將 Null 字串傳遞至 Int32.Parse方法會擲回ArgumentNullException,而傳遞空字串則會擲回 FormatException 在其他情況下,方法引數可以為 Null 字串或空字串。 例如,如果您要提供類別的 IFormattable 實作,可以使用一般 ("G") 格式指定名稱使 Null 字串和空字串相等。

String 類別包含下列可測試字串是否為 null 或空白的兩種方便方法:

  • IsNullOrEmpty ,表示字串是否為 null 或等於 String.Empty 這個方法不需要使用如下列的程式碼:

    
    if (str == null || str.Equals(String.Empty))
    
    
    
  • IsNullOrWhiteSpace ,表示字串是否為 null、等於 String.Empty 或者只包含空白字元。 這個方法不需要使用如下列的程式碼:

    
    if (str == null || str.Equals(String.Empty) || str.Trim().Equals(String.Empty))
    
    
    

下列範例在自訂 Temperature 類別的 IFormattable.ToString 實作中使用 IsNullOrEmpty 方法。 該方法支援 "G"、"C"、"F" 和 "K" 格式字串。 如果將空格式字串或值為 null 的空格式字串傳遞至方法,會將其值變更為「G」格式字串。


public string ToString(string format, IFormatProvider provider) 
{
   if (String.IsNullOrEmpty(format)) format = "G";  
   if (provider == null) provider = CultureInfo.CurrentCulture;

   switch (format.ToUpperInvariant())
   {
      // Return degrees in Celsius.    
      case "G":
      case "C":
         return temp.ToString("F2", provider) + "°C";
      // Return degrees in Fahrenheit.
      case "F": 
         return (temp * 9 / 5 + 32).ToString("F2", provider) + "°F";
      // Return degrees in Kelvin.
      case "K":   
         return (temp + 273.15).ToString();
      default:
         throw new FormatException(
               String.Format("The {0} format string is not supported.", 
                             format));
   }                                   
}


不變性和 StringBuilder 類別

String 物件稱為不可變動的 (唯讀),因為建立它之後便無法修改它的值。 看起來好像會修改 String 物件的方法,其實是傳回包含已修改的新 String 物件。

由於字串是不可變的,因此對看來只是單一字串之項目執行重複加入或刪除作業的字串操作常式可能會為效能帶來嚴重的負面影響。 例如,下列程式碼使用亂數產生器,在 0x0001 到 0x052F 的範圍中建立含 1000 個字元的字串。 儘管程式碼似乎是使用字串串連將新的字元附加至名為 str 的現有字串,但它實際上會為每個串連作業建立新的 String 物件。


using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();

      string str = String.Empty;
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                           false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         str += Convert.ToChar(rnd.Next(1, 0x0530)); 
         if (str.Length % 60 == 0)
            str += Environment.NewLine;          
      }                    
      sw.Write(str);
      sw.Close();
   }
}


在對字串值進行多重變更的作業中,您可以使用 StringBuilder 類別取代 String 類別。 String 類別執行個體不同的是,StringBuilder 物件是可變的;當您串連、附加或刪除字串中的子字串時,作業是在單一字串上執行。 當您完成修改 StringBuilder 物件的值時,可以呼叫其 StringBuilder.ToString 方法,將它轉換為字串。 下列範例取代上述範例中所用的 String,以 StringBuilder 物件串連範圍 0x0001 到 0x052F 中的 1000 個隨機字元。


using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      StringBuilder sb = new StringBuilder();
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                                         false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         sb.Append(Convert.ToChar(rnd.Next(1, 0x0530))); 
         if (sb.Length % 60 == 0)
            sb.AppendLine();          
      }                    
      sw.Write(sb.ToString());
      sw.Close();
   }
}


序數比較文化特性的作業。

String 類別的成員會對 String 物件執行序數作業或區分文化特性 (語意) 的作業。 序數作業作用在每個 Char 物件的數字值上。 而區分文化特性的作業會處理 String 物件的值,並且考慮與文化特性相關的大小寫、排序、格式化和剖析規則。 區分文化特性作業是在明確宣告文化特性或隱含目前文化特性的內容中執行。 這兩種作業在相同字串上執行時可能會產生非常不同的結果。

安全性注意事項安全性提示

如果應用程式做了關於符號識別項 (例如檔名或具名管道) 或保存資料 (例如 XML 檔案中的文字資料) 的安全性決策,則作業就應該使用序數比較,而非區分文化特性的比較。 這是因為區分文化特性的比較可以根據作用的文化特性來產生不同的結果,而序數比較則只能根據所比較字元的二進位值。

重要事項重要事項

執行字串作業的大多數方法包括含型別 StringComparison 之參數的多載,可讓您指定該方法是執行序數作業或區分文化特性的作業。 一般情況下,您應該叫用此多載使您的方法呼叫用意更加明確。 如需對字串使用序數及區分文化特性之操作的最佳做法和指導,請參閱在 .NET Framework 中使用字串的最佳作法

載入剖析和格式比較和排序測試是否相等 的作業可以是序數或文化特性。 以下幾節將討論作業的每個分類。

s1wwdcbf.collapse_all(zh-tw,VS.110).gif大小寫慣例

大小寫規則決定如何變更 Unicode 字元的大小寫,例如從小寫變更為大寫。 通常在字串比較之前執行大小寫作業。 例如,可以將字串轉換為大寫,以便與另一個大寫字串比較。 您可以透過呼叫 ToLowerToLowerInvariant 方法,將字串中的字元轉換為小寫,並透過呼叫 ToUpperToUpperInvariant 方法,將它們轉換為大寫。 此外,您可以使用 TextInfo.ToTitleCase 方法將字串轉換為小寫。

大小寫作業可以依據目前文化特性規則、指定的文化特性或不因文化特性而異來進行。 由於大小寫對應可能會根據使用的文化特性而異,框作業的結果可能會隨著文化特性變化。 在框的實際差異在於三種類型:

  • 拉丁大寫字母 I (U+0049),拉丁小寫字母 I (U+0069),拉丁大寫字母有點上方 (U+0130) 和拉丁小寫字母無點 I (U+0131) 在大小寫對應的差異。 在 tr-TR (土耳其文 (土耳其)) 然後 az-Latn-AZ (亞塞拜然,拉丁) 文化特性,以及 tr、az 和 az-Latn 中性文化特性,拉丁大寫字母小寫的 I 是拉丁小寫字母沒有點的 i ,拉丁大寫字母大寫的 I 是有上面一點的拉丁大寫字母 I。 在其他文化特性,包括不因文化特性而異、拉丁小寫字母 I 和拉丁大寫字母 I 是小寫和大寫對應項。

    下列範例示範字串比較如何設計防止檔案系統存取會失敗,如果依文化特性的大小寫的比較。(應該使用不因文化特性而異的大小寫慣例)。

    
    using System;
    using System.Globalization;
    using System.Threading;
    
    public class Example
    {
       const string disallowed = "file";
    
       public static void Main()
       {
          IsAccessAllowed(@"FILE:\\\c:\users\user001\documents\FinancialInfo.txt");
       }
    
       private static void IsAccessAllowed(String resource)
       {
          CultureInfo[] cultures = { CultureInfo.CreateSpecificCulture("en-US"),
                                     CultureInfo.CreateSpecificCulture("tr-TR") };
          String scheme = null;
          int index = resource.IndexOfAny( new Char[] { '\\', '/' } );
          if (index > 0) 
             scheme = resource.Substring(0, index - 1);
    
          // Change the current culture and perform the comparison.
          foreach (var culture in cultures) {
             Thread.CurrentThread.CurrentCulture = culture;
             Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName);
             Console.WriteLine(resource);
             Console.WriteLine("Access allowed: {0}", 
                               ! String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase));      
             Console.WriteLine();
          }   
       }
    }
    // The example displays the following output:
    //       Culture: English (United States)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: False
    //       
    //       Culture: Turkish (Turkey)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: True
    
    
    
  • 在非變異文化特性和其他文化特性之間的大小寫對應差異。 在這些情況下,使用不因文化特性而異的大小寫規則變更字元為大寫或小寫傳回相同的字元。 對於其他文化特性,它會傳回不同的字元。 某些受影響的字元在下表中列出。

    字元

    如果變更

    傳回

    微米 (百萬分之一米) 標記 (U+00B5)

    大寫

    希臘文大寫字母 MU (U+-39C)

    上面有點的拉丁大寫字母 I (U+0130)

    小寫

    拉丁小寫字母 I (U+0069)

    沒有點的拉丁小寫字母 I (U+0131)

    大寫

    拉丁大寫字母 I (U+0049)

    拉丁小寫字母長 S (U+017F)

    大寫

    拉丁大寫字母 S (U+0053)

    與小 Z 字母 LATIN CAPITAL LETTER D 與 CARON (U+01C5)

    小寫

    與 CARON (U+01C6) 的拉丁小寫字母 DZ

    合併希臘文 YPOGEGRAMMENI (U+0345)

    大寫

    希臘文大寫字母 IOTA (U+0399)

  • 兩個字母混合大小寫對應在 ASCII 字元範圍配對的差異。 在大部分的文化特性,一個兩個字母混合大小寫轉換至相等的兩個字母大小寫的相等。 因為在每種情況下它們與有向圖形比較,這不適用於下列文化特性的下列兩個字母:

    • 「lJ」和「nJ」在 hr-HR (克羅埃西亞文 (克羅埃西亞)) 文化特性。

    • 「cH」在 cs-CZ (捷克文 (捷克共和國)) 和 sk-SK (斯洛伐克文 (斯洛伐克文)) 文化特性。

    • 「aA」在 da-DK (丹麥文 (丹麥)) 文化特性。

    • 「cS」、「dZ」、「dZS」、「nY」、「sZ」、「tY」和「zS」在 hu-HU (匈牙利文 (匈牙利)) 文化特性。

    • 「cH」和「lL」在 es-ES_tradnl (西班牙文 (西班牙,傳統式排序) 文化特性。

    • 「cH」,「gI」,「kH」,「nG」,「nH」,「pH」, 「qU」,「tH」和「tR」在 vi-VN (越南文 (越南)) 文化特性。

    不過,遇到這些文化特性的比較配對建立問題的情況並不常見,因為這些屬性並不常用在固定字串或識別項。

下列範例說明將字串轉換為大寫時不同文化特性在大小寫規則方面的差異。


using System;
using System.Globalization;
using System.IO;

public class Example
{
   public static void Main()
   {
      StreamWriter sw = new StreamWriter(@".\case.txt");   
      string[] words = { "file", "sıfır", "Dženana" };
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"),  
                                 new CultureInfo("tr-TR") };

      foreach (var word in words) {
         sw.WriteLine("{0}:", word);
         foreach (var culture in cultures) {
            string name = String.IsNullOrEmpty(culture.Name) ? 
                                 "Invariant" : culture.Name;
            string upperWord = word.ToUpper(culture);
            sw.WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                         upperWord, ShowHexValue(upperWord));

         }
         sw.WriteLine();  
      }
      sw.Close();
   }

   private static string ShowHexValue(string s)
   {
      string retval = null;
      foreach (var ch in s) {
         byte[] bytes = BitConverter.GetBytes(ch);
         retval += String.Format("{0:X2} {1:X2} ", bytes[1], bytes[0]);     
      }
      return retval;
   } 
}
// The example displays the following output:
//    file:
//        Invariant:    FILE               00 46 00 49 00 4C 00 45 
//            en-US:    FILE               00 46 00 49 00 4C 00 45 
//            tr-TR:    FİLE               00 46 01 30 00 4C 00 45 
//    
//    sıfır:
//        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52 
//            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//    
//    Dženana:
//        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41 
//            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
//            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 


s1wwdcbf.collapse_all(zh-tw,VS.110).gif剖析和格式化

格式化和剖析是反向作業。 格式化規則決定如何將日期和時間或編號的值轉換為其字串表示,而剖析規則則決定如何將字串表示轉換為日期和時間之類的值。 格式化和剖析規則都取決於文化特性慣例。 下列範例說明在解譯文化特性特定的日期字串時可能發生模稜兩可的情況。 缺乏用來產生日期字串之文化特性慣例的資訊,便無法得知 03/01/2011、3/1/2011 和 01/03/2011 表示 2011 年 1 月 3 日還是 2011 年 3 月 1 日。


using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime date = new DateTime(2011, 3, 1);
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"), 
                                 new CultureInfo("fr-FR") };

      foreach (var culture in cultures)
         Console.WriteLine("{0,-12} {1}", String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.ToString("d", culture));                                    
   }
}
// The example displays the following output:
//       Invariant    03/01/2011
//       en-US        3/1/2011
//       fr-FR        01/03/2011


同樣地,如下列範例所示,依據剖析作業中所用的文化特性慣例,單一字串可以產生不同的日期。


using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string dateString = "07/10/2011";
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 CultureInfo.CreateSpecificCulture("en-GB"), 
                                 CultureInfo.CreateSpecificCulture("en-US") };
      Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}\n", "Date String", "Culture", 
                                                 "Month", "Day");
      foreach (var culture in cultures) {
         DateTime date = DateTime.Parse(dateString, culture);
         Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                           String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.Month, date.Day);
      }                      
   }
}
// The example displays the following output:
//       Date String     Culture    Month      Day
//       
//       07/10/2011    Invariant        7       10
//       07/10/2011        en-GB       10        7
//       07/10/2011        en-US        7       10


s1wwdcbf.collapse_all(zh-tw,VS.110).gif字串比較和排序

比較和排序字串慣例與文化特性而異的文化特性。 例如,排序次序可能語音數學或根據字元的視覺化表示。 在東亞語系中,排序次序可依筆劃和文字字根進行。 排序也是根據命令語言和文化特性使用字母的。 例如,丹麥文的 "Æ" 字元的字母排列在 "Z" 之後。 此外,比較是區分大小寫或不區分大小寫的,因此,在某些情況下大小寫規則由文化特性也不同。 當比較和排序字串時,序數比較,另一方面,會使用個別字元的 Unicode 字碼指標。

排序規則決定 Unicode 字元的字母順序,並決定如何比較兩個字串。 例如,String.Compare(String, String, StringComparison) 方法會根據 StringComparison 參數比較兩個字串。 如果參數值為 StringComparison.CurrentCulture,方法會執行使用目前文化特性的慣例的語言比較;如果參數值為 StringComparison.Ordinal,方法則會執行序數比較。 因此,如下列範例所示,如果目前文化特性是英文 (美國),第一次呼叫 String.Compare(String, String, StringComparison) 方法 (使用文化特性的比較) 考慮「a」小於「A」,不過,對相同方法的第二個呼叫 (使用序數比較) 考慮「a」大於「A」。


using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
      Console.WriteLine(String.Compare("A", "a", StringComparison.CurrentCulture));
      Console.WriteLine(String.Compare("A", "a", StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       1
//       -32


.NET Framework 支援字、字串和序數排序規則:

  • 字組排序執行區分文化特性的字串比較,而其中某些非英數字元的 Unicode 字元可能有指派的特殊加權。 例如,連字號 (-) 可能就會指定很小的權重,以便在排序清單中讓 "coop" 和 "co-op" 彼此相鄰列出。 如需使用字組排序規則比較兩個字串之 String 方法的清單,請參閱分類的字串作業一節。

  • 字串排序也會執行區分文化特性的比較。 它類似於字排序,只是沒有特殊大小寫,而且所有非英數字符號都在所有英數字 Unicode 字元之前。 可以透過呼叫 CompareInfo.Compare 方法多載,並提供 CompareOptions.StringSort 值給 options 參數,使用字串排序規則來比較兩個字串。 請注意,這是 .NET Framework 所提供、使用字串排序規則比較兩個字串的唯一方法。

  • 序數排序會根據字串中各個 Char 物件的數值為字串進行排序。 序數比較會自動區分大小寫,因為字元的小寫和大寫各有不同的字碼指標。 但是,如果大小寫並不重要的話,您可以指定忽略大小寫的序數比較。 這就等於使用不變文化特性來將字串轉換成大寫,然後在結果上執行序數比較。 如需使用順序排序規則比較兩個字串之 String 方法的清單,請參閱分類的字串作業一節。

區分文化特性的比較就是任何明確或隱含地使用 CultureInfo 物件的比較,包括 CultureInfo.InvariantCulture 屬性所指定的不變文化特性。 隱含文化特性是目前的文化特性,它是由 Thread.CurrentCultureCultureInfo.CurrentCulture 屬性所指定。 字母字元的排序次序的大量的變更跨文化特性 (即會在 Char.IsLetter 屬性傳回 true)。 您可以指定透過提供對字串比較方法的 CultureInfo 物件所使用的特定文化特性慣例 (如 Compare(String, String, CultureInfo, CompareOptions)) 的文化特性的比較。 您可以指定以 StringComparison.CurrentCultureStringComparison.CurrentCultureIgnoreCase,或 CompareOptions 列舉型別的所有成員使用目前文化特性慣例刪除 CompareOptions.OrdinalCompareOptions.OrdinalIgnoreCase 以外的值給 Compare 方法的適當多載的文化特性的比較。 區分文化特性的比較一般適合用來排序,而序數比較則不適合。 序數比較通常適合用來判斷兩個字串是否相等 (也就是判斷識別),而區分文化特性的比較則不適合。

下列範例說明文化特性和序數比較之間的差異。 使用每個位元是預設文化特性的 Compare 方法時所呼叫的 da-DK 和 en-US 文化特性 (,以及序數比較的慣例,範例將評估三個字串, 「Apple」, 「Æble」和「AEble」。 由於丹麥文會將字元「Æ」視為個別並在字母「Z "之後」字母排列位於字母,字串「Æble」大於「Apple」。 不過, 「Æble」未被視為等於「AEble」,因此, 「Æble」或大於「AEble」。en-US 文化特性沒有字母 Æ,而是將它視為「AE」,將「Æble」為何小於「Apple」,但是等於「AEble」。 序數比較,另一方面,視為「Apple」小於「Æble」,因此, 「Æble」ttto 請大於「AEble」。


using System;
using System.Globalization;
using System.Threading;

public class CompareStringSample
{
   public static void Main()
   {
      string str1 = "Apple";
      string str2 = "Æble"; 
      string str3 = "AEble";

      // Set the current culture to Danish in Denmark.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));

      // Set the current culture to English in the U.S.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));

      // Perform an ordinal comparison.
      Console.WriteLine("Ordinal comparison");
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, 
                        String.Compare(str1, str2, StringComparison.Ordinal));
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, 
                        String.Compare(str2, str3, StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       Current culture: da-DK
//       Comparison of Apple with Æble: -1
//       Comparison of Æble with AEble: 1
//       
//       Current culture: en-US
//       Comparison of Apple with Æble: 1
//       Comparison of Æble with AEble: 0
//       
//       Ordinal comparison
//       Comparison of Apple with Æble: -133
//       Comparison of Æble with AEble: 133


使用下列一般方針選擇適當的排序或字串比較方法:

  • 如果您要將已排序的字串會根據使用者的文化特性,您應根據目前文化特性的慣例排列它們。 如果使用者的文化特性變更,據此使用的字串排序順序將也會變更。 例如,同義字應用程式一定要依據使用者文化排序特性的文字。

  • 如果您要將字串以特定文化特性排序,您的慣例應藉由提供代表該文化特性的比較方法的 CultureInfo 物件排序它們。 例如,在應用程式設計一學生特定語言,您想要字串已排序並根據該語言慣例其中一個文化特性。

  • 如果您想要的順序維持不變跨文化特性,您應以不因文化特性的慣例或使用序數比較排列它們。 例如,您會使用序數排序組織檔案、處理序、Mutex 或具名管道的名稱。

  • 對於包含一個安全性決策的比較 (例如使用者名稱是否有效),您也應該呼叫 Equals 方法的多載一定會執行相等的循序測試。

注意事項注意事項

字串比較中使用的區分文化特性排序和大小寫規則取決於 .NET Framework 的版本。 在執行 Windows 8 作業系統的 .NET Framework 4.5 ,排序,載入,正規化和 Unicode 字元資訊符合 Unicode 6.0 標準。 在其他作業系統上,它符合 Unicode 5.0 標準。

如需字組、字串和序數排序規則的詳細資訊,請參閱 System.Globalization.CompareOptions 主題。 如需使用每項規則之時機的額外建議,請參閱在 .NET Framework 中使用字串的最佳作法

通常,您不會直接呼叫字串比較方法 (如Compare),以決定字串的排序次序。 反之,比較方法是透過 Array.SortList<T>.Sort 之類的排序方法所呼叫的。 下列範例會執行四種不同排序作業 (使用目前文化特性的字組排序,使用不因文化特性而異之字組排序,序數排序和字串排序使用不因文化特性而異),而不需要明確呼叫字串比較方法,不過,它們指定此排序是用來比較的類型。 請注意,每種排序類型都會在字串陣列中產生唯一的字串排序。


using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] strings = { "coop", "co-op", "cooperative", 
                           "co\u00ADoperative", "cœur", "coeur" };

      // Perform a word sort using the current (en-US) culture.
      string[] current = new string[strings.Length]; 
      strings.CopyTo(current, 0); 
      Array.Sort(current, StringComparer.CurrentCulture);

      // Perform a word sort using the invariant culture.
      string[] invariant = new string[strings.Length];
      strings.CopyTo(invariant, 0); 
      Array.Sort(invariant, StringComparer.InvariantCulture);

      // Perform an ordinal sort.
      string[] ordinal = new string[strings.Length];
      strings.CopyTo(ordinal, 0); 
      Array.Sort(ordinal, StringComparer.Ordinal);

      // Perform a string sort using the current culture.
      string[] stringSort = new string[strings.Length];
      strings.CopyTo(stringSort, 0); 
      Array.Sort(stringSort, new SCompare());

      // Display array values
      Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}\n", 
                        "Original", "Word Sort", "Invariant Word", 
                        "Ordinal Sort", "String Sort");
      for (int ctr = 0; ctr < strings.Length; ctr++)
         Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                           strings[ctr], current[ctr], invariant[ctr], 
                           ordinal[ctr], stringSort[ctr] );          
   }
}

// IComparer<String> implementation to perform string sort.
internal class SCompare : IComparer<String>
{
   public int Compare(string x, string y)
   {
      return CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort);
   }
}
// The example displays the following output:
//         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort
//    
//             coop          cœur            cœur         co-op         co-op
//            co-op         coeur           coeur         coeur          cœur
//      cooperative          coop            coop          coop         coeur
//     co­operative         co-op           co-op   cooperative          coop
//             cœur   cooperative     cooperative  co­operative   cooperative
//            coeur  co­operative    co­operative          cœur  co­operative


提示提示

在內部, .NET Framework 會使用排序鍵支援區分文化特性的字串比較。 字串中各個字元都被賦予數個分類的排序權重,包括指令碼、字母順序、大小寫和變音符號權重。 排序鍵,由 SortKey 類別,為特定字串提供這些權重儲存機制。 如果您的應用程式對同一組的大量搜尋或排序作業字串,可以產生並儲存它使用的任何字串的排序鍵可改善其效能。 如果需要排序或比較作業,您可以使用排序鍵而不是字串。 如需詳細資訊,請參閱 SortKey 類別。

如果您不指定字串比較慣例,排序方法 (例如 Array.Sort(Array) ) 會對字串的特定文化特性,區分大小寫的排序。 下列範例說明如何變更目前文化特性如何影響排序順序的字串陣列中的。 它會建立陣列三個字串。 首先,它會將屬性設定為 System.Threading.Thread.CurrentThread.CurrentCulture en-US Array.Sort(Array) 並呼叫方法。 產生的排序次序將使用英文 (美國) 文化特性的排序慣例做為依據。 接著,此範例會 System.Threading.Thread.CurrentThread.CurrentCulture 屬性設為 da-DK Array.Sort 並再次呼叫方法。 由於使用的是 da-DK 文化特性的排序慣例,因此請注意產生的排序次序與 en-US 結果有何不同之處。


using System;
using System.Globalization;
using System.Threading;

public class ArraySort 
{
   public static void Main(String[] args) 
   {
      // Create and initialize a new array to store the strings.
      string[] stringArray = { "Apple", "Æble", "Zebra"};

      // Display the values of the array.
      Console.WriteLine( "The original string array:");
      PrintIndexAndValues(stringArray);

      // Set the CurrentCulture to "en-US".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      // Sort the values of the array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"en-US\":");
      PrintIndexAndValues(stringArray); 

      // Set the CurrentCulture to "da-DK".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      // Sort the values of the Array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"da-DK\":");
      PrintIndexAndValues(stringArray); 
   }
   public static void PrintIndexAndValues(string[] myArray)  
   {
      for (int i = myArray.GetLowerBound(0); i <= 
            myArray.GetUpperBound(0); i++ )
         Console.WriteLine("[{0}]: {1}", i, myArray[i]);
      Console.WriteLine();      
   }
}
// The example displays the following output:
//       The original string array:
//       [0]: Apple
//       [1]: Æble
//       [2]: Zebra
//       
//       After sorting for the "en-US" culture:
//       [0]: Æble
//       [1]: Apple
//       [2]: Zebra
//       
//       After sorting for the culture "da-DK":
//       [0]: Apple
//       [1]: Zebra
//       [2]: Æble


注意事項警告

如果比較字串的主要目的是為了判斷它們是否相等,則應叫用String.Equals方法。 您通常應該使用 Equals 以執行序數比較。 String.Compare 方法主要用於排序字串。

字串搜尋方法,例如 String.StartsWithString.IndexOf,也可以執行區分文化特性或序數的字串比較。 下列範例說明使用 IndexOf 方法時序數和區分文化特性的比較差異。 區分文化特性的搜尋,其目前使用的文化特性英文 (美國) 會將子字串 "oe" 視為符合連音符 "œ"。 由於選擇性連字號 (U+00AD) 是零寬度字元,搜尋會將選擇性連字號視為等同於 Empty,並且會在字串開頭找到符合項目。 此外,序數搜尋在任一情況下都不會找到符合項目。


using System;

public class Example
{
   public static void Main()
   {
      // Search for "oe" and "œu" in "œufs" and "oeufs".
      string s1 = "œufs";
      string s2 = "oeufs";
      FindInString(s1, "oe", StringComparison.CurrentCulture);
      FindInString(s1, "oe", StringComparison.Ordinal);
      FindInString(s2, "œu", StringComparison.CurrentCulture);
      FindInString(s2, "œu", StringComparison.Ordinal);
      Console.WriteLine();

      string s3 = "co\u00ADoperative";
      FindInString(s3, "\u00AD", StringComparison.CurrentCulture);
      FindInString(s3, "\u00AD", StringComparison.Ordinal);
   }

   private static void FindInString(string s, string substring, StringComparison options)
   {
      int result = s.IndexOf(substring, options);
      if (result != -1)
         Console.WriteLine("'{0}' found in {1} at position {2}", 
                           substring, s, result);
      else
         Console.WriteLine("'{0}' not found in {1}", 
                           substring, s);                                                  
   }
}
// The example displays the following output:
//       'oe' found in œufs at position 0
//       'oe' not found in œufs
//       'œu' found in oeufs at position 0
//       'œu' not found in oeufs
//       
//       '­' found in co­operative at position 0
//       '­' found in co­operative at position 2


s1wwdcbf.collapse_all(zh-tw,VS.110).gif搜尋字串

字串搜尋方法,例如 String.StartsWithString.IndexOf,可能也會執行判斷文化特性或序數字串比較字元或子字串是否在指定字串中找到。

搜尋方法可讓您搜尋字元或一組該字串中的字元,或是搜尋字串中的子字串。 搜尋個別字元,例如 IndexOf 方法或一組字元,例如 IndexOfAny 方法,所有執行循序的搜尋搜尋 String 方法將該分類。 若要執行區分文化特性的搜尋字元,您必須呼叫 CompareInfo 方法 (例如 CompareInfo.IndexOf(String, Char)CompareInfo.LastIndexOf(String, Char) 請注意搜尋的結果會使用序數和文化特性比較的字元可以是非常不同。 例如,搜尋一 precomposed Unicode 字元 (例如連字「Æ」(U+00C6) 可能會因文化特性符合其組成元件以正確序列出現任何事件,例如「AE」(U+041U+0045)。 要用來搜尋個別字元時,下列範例會說明如何在 String.IndexOf(Char)CompareInfo.IndexOf(String, Char) 方法之間的差異。 連字「æ」(U+00E6) 在字串「架空」中發現,當使用 en-US 文化特性的慣例,不過,沒有時,當使用 da-DK 文化特性,或是執行序數時比較的慣例。


using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      String[] cultureNames = { "da-DK", "en-US" };
      CompareInfo ci;
      String str = "aerial";
      Char ch = 'æ';  // U+00E6

      Console.Write("Ordinal comparison -- ");
      Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                        str.IndexOf(ch));

      foreach (var cultureName in cultureNames) {
         ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo;
         Console.Write("{0} cultural comparison -- ", cultureName);
         Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                           ci.IndexOf(str, ch));
      }
   }
}
// The example displays the following output:
//       Ordinal comparison -- Position of 'æ' in aerial: -1
//       da-DK cultural comparison -- Position of 'æ' in aerial: -1
//       en-US cultural comparison -- Position of 'æ' in aerial: 0


另一方面, String 搜尋字串而非字元執行區分文化特性的搜尋的類別方法,如果搜尋選項型別所未明確指定 StringComparison參數。 單一例外狀況是 Contains,執行循序的搜尋。

s1wwdcbf.collapse_all(zh-tw,VS.110).gif測試是否相等

使用 String.Compare 方法以判斷兩個字串在排序次序中的關聯性。 這通常是區分文化特性的作業。 反之,呼叫 String.Equals 方法來測試相等性。 由於相等測試一般會將使用者輸入與一些已知的字串 (例如有效的使用者名稱、密碼或檔案系統路徑) 進行比較,因此這個測試通常是序數作業。

注意事項警告

可以呼叫 String.Compare方法並判斷傳回值是否為零,以測試相等性。 但是,不推薦這樣做。 若要比較兩個字串是否相等,您必須呼叫 String.Equals 方法的其中一個多載。 呼叫的慣用多載是執行個體 Equals(String, StringComparison) 方法或靜態 Equals(String, String, StringComparison) 方法,因為這兩種方法都包含明確指定比較類型的 System.StringComparison 參數。

下列範例說明在應改用序數比較時執行區分文化特性的相等比較的危險。 在這種情況下,程式碼的用途是禁止檔案系統針對以字串 "FILE"//" 開頭的 URL 執行不區分大小寫的比較,從以 "FILE://" 或 "file://" 開頭的 URL 進行存取。 但是,如果在以 "file://" 開頭的 URL 使用土耳其文 (土耳其) 文化特性執行區分文化特性的比較,相等性比較會失敗,因為與土耳其文小寫 i 對等的大寫是 "İ" 而不是"I"。 因此,會在無意中允許檔案系統存取。 另一方面,如果執行序數比較,相等比較會成功,而且檔案系統存取會被拒絕。


using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR");      

      string filePath = "file://c:/notes.txt";

      Console.WriteLine("Culture-sensitive test for equality:");
      if (! TestForEquality(filePath, StringComparison.CurrentCultureIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);

      Console.WriteLine("\nOrdinal test for equality:");
      if (! TestForEquality(filePath, StringComparison.OrdinalIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);
   }

   private static bool TestForEquality(string str, StringComparison cmp)
   {
      int position = str.IndexOf("://");
      if (position < 0) return false;

      string substring = str.Substring(0, position);  
      return substring.Equals("FILE", cmp);
   }
}
// The example displays the following output:
//       Culture-sensitive test for equality:
//       Access to file://c:/notes.txt is allowed.
//       
//       Ordinal test for equality:
//       Access to file://c:/notes.txt is not allowed.


正規化

某些 Unicode 字元具有多個表示。 例如,下列任何字碼元素皆可代表字母 "ắ":

  • U+1EAF

  • U+0103 U+0301

  • U+0061 U+0306 U+0301

單一字元有多種表示,使得搜尋、排序、比對和其他字串作業變得更為複雜。

Unicode 標準會定義稱為正規化的程序,這個程序會為任何對等二進位表示傳回一個 Unicode 字元的二進位表示。 正規化可以使用多種演算法,這些演算法稱為正規化表單,必須遵守不同的規則。 .NET Framework 支援 Unicode 正規化格式 C、D、KC 及 KD。 如果字串正規化為相同的正規化表單,字串就可以透過序數比較進行比較。

序數比較是每個字串的對應之 Char 物件的 Unicode 數值類值的二進位比較。 String 類別包含可執行序數比較的一些方法,包括:

您可以呼叫 String.IsNormalized() 方法來判斷字串是否正規化為正規化表單 C,並呼叫 String.IsNormalized(NormalizationForm) 方法來判斷字串是否正規化為指定的正規化表單。 您也可以呼叫 String.Normalize() 方法,將字串正規化為正規化表單 C,或呼叫 String.Normalize(NormalizationForm) 方法,將字串正規化為指定的正規化表單。 如需正規化和比較字串的逐步資訊,請參閱 Normalize()Normalize(NormalizationForm) 方法。

下列簡易範例說明字串正規化。 它在三個不同字串中以三種不同的方式定義字母 "ố",並且使用序數品質比較來決定每個字串都和另外兩個字串不同。 接著它會將每個字串轉換為受支援的正規化形式,然後再次依指定正規化形式執行每個字串的序數比較。 在任何情況下,第二次相等測試顯示字串是相等的。


using System;
using System.Globalization;
using System.IO;
using System.Text;

public class Example
{
   private static StreamWriter sw;

   public static void Main()
   {
      sw = new StreamWriter(@".\TestNorm1.txt");

      // Define three versions of the same word. 
      string s1 = "sống";        // create word with U+1ED1
      string s2 = "s\u00F4\u0301ng";
      string s3 = "so\u0302\u0301ng";

      TestForEquality(s1, s2, s3);      
      sw.WriteLine();

      // Normalize and compare strings using each normalization form.
      foreach (string formName in Enum.GetNames(typeof(NormalizationForm)))
      {
         sw.WriteLine("Normalization {0}:\n", formName); 
         NormalizationForm nf = (NormalizationForm) Enum.Parse(typeof(NormalizationForm), formName);
         string[] sn = NormalizeStrings(nf, s1, s2, s3);
         TestForEquality(sn);           
         sw.WriteLine("\n");                                        
      }

      sw.Close();   
   }

   private static void TestForEquality(params string[] words)
   {
      for (int ctr = 0; ctr <= words.Length - 2; ctr++)
         for (int ctr2 = ctr + 1; ctr2 <= words.Length - 1; ctr2++) 
            sw.WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words[ctr], ShowBytes(words[ctr]),
                         words[ctr2], ShowBytes(words[ctr2]),
                         words[ctr].Equals(words[ctr2], StringComparison.Ordinal));
   }

   private static string ShowBytes(string str)
   {
      string result = null;
      foreach (var ch in str)
         result += String.Format("{0} ", Convert.ToUInt16(ch).ToString("X4")); 
      return result.Trim();            
   } 

   private static string[] NormalizeStrings(NormalizationForm nf, params string[] words)
   {
      for (int ctr = 0; ctr < words.Length; ctr++)
         if (! words[ctr].IsNormalized(nf))
            words[ctr] = words[ctr].Normalize(nf); 
      return words;   
   }
}
// The example displays the following output:
//       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False
//       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       
//       Normalization FormC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       
//       
//       Normalization FormKC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormKD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True


如需正規化和正規化格式的詳細資訊,請參閱 System.Text.NormalizationForm,以及 Unicode 標準附錄 #15:Unicode 正規化格式正規化 FAQ unicode.org 網站。

依分類排列的字串作業

String 類別提供用於下列用途的成員:比較字串、測試字串是否相等、在字串中尋找字元或子字串、修改字串、從字串擷取子字串、組合字串、格式化值、複製字串,以及正規化字串。

s1wwdcbf.collapse_all(zh-tw,VS.110).gif比較字串

您可以透過使用下列 String 方法,比較字串,以判斷它們在排序次序中的相對位置:

  • Compare 會傳回整數,表示字串與依序第二個字串之間的關聯。

  • CompareOrdinal  會傳回整數,根據比較字串字碼元素表示兩個字串的關係。

  • CompareTo 會傳回整數,表示目前的字串執行個體與依序第二個字串之間的關連。 CompareTo(String) 方法提供 String 類別的 IComparableIComparable<T> 實作。

s1wwdcbf.collapse_all(zh-tw,VS.110).gif測試字串是否相等

您可以呼叫 Equals 方法,判斷兩個字串是否相同。 執行個體 Equals(String, String, StringComparison) 和靜態 Equals(String, StringComparison) 多載可讓您指定比較是區分文化特性還是序數,以及要考慮還是忽略大小寫。 大多數相等性測試是序數測試,且判斷存取系統資源 (例如檔案系統物件)的相等性比較一律是序數比較。

s1wwdcbf.collapse_all(zh-tw,VS.110).gif尋找字串中的字元

String 類別包含兩種搜尋方法:

注意事項警告

如果您想要在中搜尋字串特定樣式而不是一個特定的子字串,您應該使用規則運算式。 如需詳細資訊,請參閱.NET Framework 規則運算式

s1wwdcbf.collapse_all(zh-tw,VS.110).gif修改字串

String 類別包含下列看起來好像會修改字串值的方法:

  • Insert 會將字串插入到目前的 String 執行個體。

  • PadLeft 會在字串開頭插入一次或多次指定的字元。

  • PadRight 會在字串開頭插入一次或多次指定的字元。

  • Remove 會從目前的 String 執行個體刪除子字串。

  • Replace 會以目前的 String 執行各體中的子字串取代另一個子字串。

  • ToLower ToLowerInvariant 會將字串中的所有字元轉換為小寫。

  • ToUpper ToUpperInvariant 會將字串中的所有字元轉換為大寫。

  • Trim 會將出現在字串開頭和結尾的某個字元全數移除。

  • TrimEnd 會將出現在字串結尾的某個字元全數移除。

  • TrimStart 會將出現在字串開頭的某個字元全數移除。

重要事項重要事項

所有字串修改方法都會傳回新的 String 物件。 它們不會修改目前執行個體的值。

s1wwdcbf.collapse_all(zh-tw,VS.110).gif從字串中擷取子字串

String.Split 方法會將單一字串分為多個字串。 該方法的多載可讓您指定多個分隔符號,決定方法擷取的子字串數目上限,以及決定空字串 (分隔符號是相鄰時發生) 是否包含在傳回的字串中。

s1wwdcbf.collapse_all(zh-tw,VS.110).gif合併字串

下列 String 方法可以用於字串串連:

  • Concat 會將一個或多個子字串結合為單一字串。

  • Join 會將一或多個子字串串連為單一元素,並在每個子字串之間新增分隔符號。

s1wwdcbf.collapse_all(zh-tw,VS.110).gif格式化值

String.Format 方法使用複合格式設定功能,將字串中的一個或多個預留位置取代為特定物件或值的字串表示。 Format 方法通常用來執行下列動作:

  • 將數值的字串表示內嵌在字串中。

  • 將日期和時間值的字串表示內嵌在字串中。

  • 將列舉值的字串表示內嵌在字串中。

  • 將某個支援 IFormattable 介面之物件的字串表示內嵌在字串中。

  • 將較大字串內欄位中的子字串靠右或靠左對齊。

如需格式化作業和範例的詳細資訊,請參閱 Format 多載摘要。

s1wwdcbf.collapse_all(zh-tw,VS.110).gif複製字串

您可以呼叫下列 String 方法來建立字串的複本:

  • Clone 會傳回現有 String 物件的參照。

  • Copy 會建立現有字串的複本。

  • CopyTo 會將字串的一部分複製到字元陣列中。

s1wwdcbf.collapse_all(zh-tw,VS.110).gif正規化字串

在 Unicode 中,單一字元可以有多個字碼元素。 正規化會將這些相等的字元轉換為相同的二進位表示形式。 String.Normalize 方法會執行正規化,而 String.IsNormalized 方法則會判斷字串是否已正規化。

.NET Framework

支援版本:4.5.2、4.5.1、4.5、4、3.5、3.0、2.0、1.1、1.0

.NET Framework Client Profile

支援版本:4、3.5 SP1

可攜式類別庫

支援版本:可攜式類別庫

適用於 Windows 市集應用程式的 .NET

支援版本:Windows 8

適用於 Windows Phone 應用程式的 .NET

支援版本:Windows Phone 8、Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (不支援伺服器核心角色), Windows Server 2008 R2 (SP1 (含) 以後版本支援伺服器核心角色,不支援 Itanium)

.NET Framework 並不支援各種平台的所有版本。如需支援版本的清單,請參閱.NET Framework 系統需求

此型別具備執行緒安全。

社群新增項目

顯示:
© 2015 Microsoft