將文本表示為 UTF-16 代碼單元的序列。

public sealed class String : ICloneable , IComparable ,
IComparable<string> , IConvertible , IEquatable<string> ,
IParsable<string> , ISpanParsable<string> ,
System . Collections . Generic . IEnumerable<char>

繼承 Object String
實現 IEnumerable < Char >；IEnumerable；IComparable；IComparable < String >；IConvertible；IEquatable < String >；ICloneable；IParsable < String >；IParsable < TSelf >；ISpanParsable < String >

構造函數

string ( Char [ ] )

初始化 String 類的新實例，使其對應於指定字符數組中指示的 Unicode 字符。
public String( char[ ]? 值);

參數

示例

char [ ] ZFs = [ 'a' , 'b' , 'c' ];
string zfc = new ( ZFs );
Console . WriteLine ( zfc );

string ( Char , int32 )

初始化 String 類的新實例，使其值為指定的 Unicode 字符重複指定次數所表示的值。
public String (char 字符 , int 個數 );

參數

異常

示例

char ZF = 'a';
string zfc = new ( ZF , 32 );
Console . WriteLine ( zfc );

字符串 (ReadOnlySpan < 字符 > )

初始化 String 類的新實例，使其指向指定的只讀範圍中指示的 Unicode 字符。
public String ( ReadOnlySpan < char > 值 );

參數

示例：

// 1. 從字符串創建 ReadonlySpan
string zfc = "你好，我的上帝啊！";
ReadOnlySpan<char> zhidu我的上帝 = zfc . AsSpan();

// 2. 從數組創建 ReadonlySpan
int [ ] Z數值 = { 1, 2, 3, 4, 5 };
ReadOnlySpan<int> SP來自數組 = Z數值 . AsSpan ( );

// 3. 使用 Slice 方法獲取子 Span
ReadOnlySpan<char> subSpan = zhidu我的上帝 . Slice ( 3 , 2 ); // 從索引 3 開始，長度2
Console . WriteLine ( subSpan . ToString ( ) ); // 輸出 "我的"

// 4. 使用 IndexOf 方法查找字符
int commaIndex = zhidu我的上帝 . IndexOf ( '，' );
Console . WriteLine ( $"逗號位置: {commaIndex}" ); // 輸出 "逗號位置: 2"

// 5. 遍歷 ReadonlySpan
Console . WriteLine ( "數組元素:" );
foreach ( int num in SP來自數組 )
    {
        Console . Write ( num + " " ); // 輸出 "1 2 3 4 5 "
    }

// 6. 嘗試修改 ReadonlySpan（會編譯錯誤）
// zhidu我的上帝 [ 0 ] = 'h'; // 錯誤：ReadonlySpan 是隻讀的

// 7. 使用 IsEmpty 屬性檢查是否為 null
Console . WriteLine ( $"\n子 Span 是否為 null：{subSpan . IsEmpty}" ); // 輸出 "子 Span 是否為 null：False"

字段

Empty

表示空字符串。此字段為只讀。
public static readonly string Empty;

字段值

備註

此字段的值是空字符串，""。

在應用程序代碼中，此字段最常用於賦值操作，以將字符串變量初始化為空字符串（不是 null，那是尚未聲明任何內容的字符串）。要測試字符串的值是 null 還是 String . Empty，請使用 IsNullOrEmpty 方法。

屬性

String . Chars [ Int32 ] 屬性

獲取當前 String 對象中指定位置的 Char 對象。
public char this [ int 索引 ] { get; }

參數

屬性值

異常

示例：

Console . WriteLine ( "請輸入任意字符：" );
string? zfc = Console . ReadLine ( );
if ( zfc != null )
    {
        for ( int i = 0 ; i < zfc . Length ; i++ )
            {
                if ( Uri . IsHexDigit ( zfc [ i ] ) )
                    Console . WriteLine ( $"{zfc [ i ]} 是一個十六進制數值。" );
                else
                    Console . WriteLine ( $"{zfc [ i ]} 不是一個十六進制數值。" );
            }
    }

備註

參數是從零開始的。

此屬性返回由 index（索引）參數指定位置處的 Char 對象。但是，一個 Unicode 字符可能由多個 Char 表示。請使用 System . Globalization . StringInfo 類來處理 Unicode 字符，而不是 Char 對象。

在 C# 中，Chars [ ] 屬性是一個索引器。在 Visual Basic 中，它是 String 類的默認屬性。可以使用如下代碼訪問字符串中的每個 Char 對象。

string zfc = "Test";
for ( int i = 0 ; i <= zfc . Length - 1 ; i++ )
   Console . Write ( $"{zfc [ i ]} " );
// 輸出：
//      T e s t

String . Length 屬性

獲取當前 String 對象中的字符數。
public int Length { get; }

屬性值

示例

    string zfc = "abcdefg";
    Console . WriteLine ( $"1）‘{zfc}’ 的長度是 {zfc . Length}" );
    Console . WriteLine ( $"2）‘{"xyz"}’ 的長度是 {"xyz" . Length}" );

    int CD = zfc . Length;
    Console . WriteLine ( $"3）‘{zfc}’ 的長度是 { CD } ");

備註

Length 屬性返回此實例中 Char 對象的數量，而非 Unicode 字符的數量。原因是一個 Unicode 字符可能由多個 Char 表示。請使用 System . Globalization . StringInfo 類來處理每個 Unicode 字符，而非每個 Char。

在某些語言中，例如 C 和 C++，null 字符表示字符串的結尾。在 .NET 中，null 字符可以嵌入到字符串中。當字符串包含一個或多個 null 字符時，這些 null 字符會被計入字符串的總長度。例如，在以下字符串中，子字符串 “abc” 和 “def” 由一個空字符分隔。Length 屬性返回 7，這表明它包含 6 個字母字符以及那個空字符。

string ZFs = "abc\u0000def";
Console . WriteLine ( ZFs . Length ); // 顯示 7

方法

String . Clone 方法

返回對此 String 實例的引用。
public object Clone ( );

返回值

Implements 實現

Clone ( )

示例：

string zfc = "abcdefg";
var zfc1 = zfc . Clone ( ) ;
Console . WriteLine ( zfc1 );

備註

返回值不是此實例的獨立副本，它只是同一數據的另一個視圖。使用 Copy 或 CopyTo 方法可創建一個與該實例具有相同值的獨立 String 對象。

由於 Clone 方法只是返回現有的字符串實例，因此幾乎沒有理由直接調用它。

String . Compare 方法

比較兩個指定的 string 對象，並返回一個整數，該整數指示它們在排序順序中的相對位置。

Compare ( string zfcA , string zfcB )

比較兩個指定的字符串對象，並返回一個整數，該整數指示它們在排序順序中的相對位置。
public static int Compare ( string? strA , string? strB );

參數

返回值

比較兩個指定的 string 對象，並返回一個整數，該整數指示它們在排序順序中的相對位置。

示例：

以下示例調用 Compare ( String , String ) 方法來比較三組字符串。

// 源自其 Unicode 代碼單元創建大寫字符
String zfc大寫 = "\x0041\x0042\x0043";

// 源自其 Unicode 代碼單元創建小寫字符
String zfc小寫 = "\x0061\x0062\x0063";

// 顯示這些字符
Console . WriteLine ( $"比較 ‘{zfc大寫}’ 和 ‘{zfc小寫}’：" );

// 比較這兩個大寫形式的字符串；結果為 true
Console . WriteLine ( $"當字符串的大小寫相同的情況下，它們是否是相等的？{( String . Compare ( zfc大寫 . ToUpper ( ) , zfc小寫 . ToUpper ( ) ) == 0 ? "true" : "false" )}" );

// 之前的調用方法與這個 “比較” 方法等同，該方法不區分大小寫
Console . WriteLine ( $"當忽略大小寫時，這些字符串是否相等？{( String . Compare ( zfc大寫 , zfc小寫 , true ) == 0 ? "true" : "false" )}" );

在下面的示例中，LEI字符串逆序比較器 類展示瞭如何使用 Compare 方法對兩個字符串進行比較。

using System . Collections;
using System . Text;

ArrayList zfcs =
[ "Eric",
"Mark",
"Lance",
"Rob",
"Kris",
"Brad",
"Kit",
"Bradley",
"Keith",
"Susan",
];

// Displays the properties and values of    the    ArrayList.
Console . WriteLine ( $"計數： {zfcs . Count}" );

FF打印值 ( "未排序" , zfcs );
zfcs . Sort ( );
FF打印值 ( "排序後" , zfcs );
zfcs . Sort ( new LEI字符串逆序比較器 ( ) );
FF打印值 ( "反轉" , zfcs );

string [ ] xingmings = ( string [ ]) zfcs . ToArray ( typeof ( string ) );

static void FF打印值 ( string 標題 , IEnumerable 列表 )
    {
    Console . Write ( "{0,10}: " , 標題 );
    StringBuilder zc = new ( );
    foreach ( string z in 列表 )
        {
        zc . Append ( $"{z}, " );
        }
    zc . Remove ( zc . Length - 2 , 2 );
    Console . WriteLine ( zc );
    }

public class LEI字符串逆序比較器 : System . Collections . IComparer
    {
    public int Compare ( object? x , object? y )
        {
        string? z1 = x as string;
        string? z2 = y as string;
        return -string . Compare ( z1 , z2 );
        }
    }

備註

這種比較會使用當前區域性來獲取特定於區域性的信息，例如大小寫規則和單個字符的字母順序。例如，某個區域性可能會規定某些字符組合應被視為單個字符，或者大小寫字符應以特定方式進行比較，又或者某個字符的排序順序取決於其前後的字符。

比較是使用單詞排序規則執行的。

一個或兩個比較數可以為 null。根據定義，任何字符串（包括空字符串（""））都大於空引用；兩個空引用彼此相等。

當發現不相等或兩個字符串都已比較完畢時，比較終止。但是，如果兩個字符串在其中一個字符串的末尾比較結果相等，而另一個字符串還有剩餘字符，則擁有剩餘字符的字符串被視為更大。返回值是最後一次比較的結果。

當比較受特定於文化的大小寫規則影響時，可能會出現意外結果。例如，在土耳其語中，下面的示例會產生錯誤結果，因為土耳其語的文件系統在 “file” 一詞中對字母 “i” 不使用語言大小寫規則。

static bool IsFileURI ( String path )
{
    return ( String . Compare ( path , 0 , "file:" , 0 , 5 , true ) == 0 );
}

使用序數比較將路徑名與 “file” 進行比較。正確的代碼如下：

static bool IsFileURI ( String path )
{
    return ( String . Compare ( path , 0 , "file:" , 0 , 5 , StringComparison . OrdinalIgnoreCase ) == 0 );
}

給調用者的説明

字符集包含可忽略字符。Compare ( String , String ) 方法在執行區域性敏感比較時不會考慮此類字符。例如，如果在 .NET Framework 4 或更高版本上運行以下代碼，對 “animal” 和 “ani-mal” （使用軟連字符，即 U+00AD）進行區域性敏感比較會表明這兩個字符串是等效的。

string z1 = "ani\u00ADmal";
string z2 = "animal";

Console . WriteLine ( $"比較 ‘{z1}’ 和 ‘{z2}’：{String . Compare( z1 , z2 )}" );

要在字符串比較中識別可忽略的字符，請調用 Compare ( String , String , StringComparison ) 方法，併為 comparisonType 參數提供 Ordinal 或 OrdinalIgnoreCase 值。

Compare ( string zfcA , string zfcB , bool 忽略大小寫 )

比較兩個指定的字符串對象，忽略或考慮它們的大小寫，並返回一個整數，該整數指示它們在排序順序中的相對位置。
public static int Compare ( string? zfcA , string? zfcB , bool 忽略大小寫 );

參數

Compare ( string zfcA , string zfcB , StringComparison 比較選項 )

使用指定的規則比較兩個指定的字符串對象，並返回一個整數，該整數指示它們在排序順序中的相對位置。
public static int Compare ( string? zfcA , string? zfcB , StringComparison 比較選項 );

參數

異常

示例

以下示例對字母 “I” 的三種版本進行了比較。結果會受到文化選擇、是否忽略大小寫以及是否執行序數比較的影響。

    {
    public static void Main ( )
        {
        string 介紹 = "使用不同的 StringComparison 值，比較字母 I 的三種版本。";

        // 定義一個字符串數組，其中每個元素包含字母 I 的一種版本。
        // （使用字符串數組是為了方便修改本代碼示例，以測試更多或不同的字符串組合。）

        string [ ] 三個I =
            [ // 拉丁小寫字母 I（U+0069）
              "\u0069",
            // 拉丁無點小寫字母 I（U+0131）
            "\u0131",
            // 拉丁大寫字母 I（U+0049）
            "\u0049",
        ];

        string [ ] unicode名稱 =
        [
            "拉丁小寫字母 I（U+0069）",
            "拉丁無點小寫字母 I（U+0131）",
            "拉丁大寫字母 I（U+0049）"
        ];

        StringComparison [ ] 字符串比較方式 =
        [
            StringComparison . CurrentCulture,                        // 當前文化
            StringComparison . CurrentCultureIgnoreCase,    // 當前文化（忽略大小寫）
            StringComparison . InvariantCulture,                     // 固定文化
            StringComparison . InvariantCultureIgnoreCase, // 固定文化（忽略大小寫）
            StringComparison . Ordinal,                                  // 序號（按字符編碼）
            StringComparison . OrdinalIgnoreCase               // 序號（按字符編碼，忽略大小寫）
        ];

        Console . Clear ( );
        Console . WriteLine ( 介紹 );

        // 顯示當前文化，因為特定於文化的比較在不同文化下可能產生不同結果。
        Console . WriteLine ( "當前文化為 {0}。\n" , Thread . CurrentThread . CurrentCulture . Name );

        // 確定字母I的三個版本的相對排序。
        foreach ( StringComparison 比較方式 in 字符串比較方式 )
            {
            Console . WriteLine ( "StringComparison.{0}：" , 比較方式 );

            // 拉丁小寫字母 I（U+0069）與拉丁無點小寫字母 I（U+0131）比較
            測試 ( 0 , 1 , 比較方式 , 三個I , unicode名稱 );

            // 拉丁小寫字母 I（U+0069）與拉丁大寫字母 I（U+0049）比較
            測試 ( 0 , 2 , 比較方式 , 三個I , unicode名稱 );

            // 拉丁無點小寫字母 I（U+0131）與拉丁大寫字母 I（U+0049）比較
            測試 ( 1 , 2 , 比較方式 , 三個I , unicode名稱 );

            Console . WriteLine ( );
            }
        }

    protected static void 測試 ( int x , int y , StringComparison 比較規則 , string [ ] 測試用I , string [ ] 測試名稱 )
        {
        string 結果格式 = "{0} {1} {2}";
        string 結果 = "等於";
        int 比較值;

        比較值 = String . Compare ( 測試用I [ x ] , 測試用I [ y ] , 比較規則 );
        if ( 比較值 < 0 )
            結果 = "小於";
        else if ( 比較值 > 0 )
            結果 = "大於";
        Console . WriteLine ( 結果格式 , 測試名稱 [ x ] , 結果 , 測試名稱 [ y ] );
        }
    }

備註

比較選項 參數指示比較應使用當前區域性還是固定區域性、區分還是忽略比較項的大小寫，或者使用單詞（區域性敏感）排序規則還是序號（區域性不敏感）排序規則。

比較 ( string zfcA , string zfcB , bool 忽略大小寫 , CultureInfo 區域性 )

比較兩個指定的字符串對象，忽略或考慮它們的大小寫，並使用特定於區域性的信息影響比較，返回一個整數，該整數指示它們在排序順序中的相對位置。
public static int Compare ( string? strA , string? strB , bool 忽略大小寫 , System . Globalization . CultureInfo? 區域性 );

參數

示例

static void Main ( )
    {
        string zfc1 = "change";
        string zfc2 = "dollar";
        string zfc關係;
        CultureInfo [ ] QuYus =
            [
            new CultureInfo ( "en-US" ),
            new CultureInfo ( "cs-CZ" ),
            ];
        foreach ( CultureInfo q in QuYus )
            {
                zfc關係 = FF標誌 ( string . Compare ( zfc1 , zfc2 , false , q ) );
                Console . WriteLine ( $"{q . Name} → {zfc1} {zfc關係} {zfc2}" );
            }
    }

private static string FF標誌 ( int z )
    {
        string zfc = "=";
        if ( z < 0 ) {  zfc = "<"; }
        else if ( z > 0 ) { zfc = ">"; }
        return zfc;
    }

備註

這種比較使用 區域性 參數來獲取特定於區域性的信息，例如大小寫規則和單個字符的字母順序。例如，一種區域性可能規定某些字符組合應被視為單個字符，或者大小寫字符應以特定方式進行比較，又或者某個字符的排序順序取決於其前後的字符。

比較是使用單詞排序規則執行的。

Compare ( zfcA , zfcB , CultureInfo , CompareOptions )

使用指定的比較選項和特定於區域性的信息來影響比較，比較兩個指定的 String 對象，並返回一個整數，該整數指示兩個字符串在排序順序中的相互關係。
public static int Compare ( string? strA , string? strB , System . Globalization . CultureInfo? 區域性 , System . Globalization . CompareOptions 比較選項 );

參數

示例

string zfc1 = "brother";
string zfc2 = "Brother";
string zfc標誌;
int Z結果;

CompareOptions [ ] XXs =
    [
    CompareOptions . None,
    CompareOptions . IgnoreCase,
    CompareOptions . Ordinal,
    ];

foreach ( var xx  in XXs )
    {
    Z結果 = string . Compare ( zfc1 , zfc2 , CultureInfo . CurrentCulture , xx );
    if ( Z結果 > 0 )
        zfc標誌 = "後於";
    else if ( Z結果 == 0 )
        zfc標誌 = "等於";
    else
        zfc標誌 = "前於";
    Console . WriteLine ( $"{xx} → {zfc1} {zfc標誌} {zfc2}\n" );
    }

備註

這種比較使用 區域性 參數來獲取特定於區域性的信息，例如大小寫規則和單個字符的字母順序。例如，特定的區域性可能會規定某些字符組合應被視為單個字符，大小寫字符應以特定方式進行比較，或者某個字符的排序順序取決於其前後的字符。

警告：Compare ( zfc1 , zfc2 , 區域性 , 比較選項 ) 方法主要用於排序或按字母順序排列操作。當方法調用的主要目的是確定兩個字符串是否等效（即方法調用的目的是測試返回值是否為零）時，不應使用此方法。要確定兩個字符串是否等效，請調用 Equals 方法。

可以通過 比較選項 參數進一步指定比較方式，該參數包含 CompareOptions 枚舉中的一個或多個成員。但是，由於此方法的目的是進行區分區域性的字符串比較，因此 CompareOptions . Ordinal 和 CompareOptions . OrdinalIgnoreCase 值不起作用。

Compare ( zfc1 , 索引1 , zfc2 , 索引2 , 長度 )

比較兩個指定的字符串對象的子字符串，並返回一個整數，該整數指示它們在排序順序中的相對位置。
public static int Compare ( string? zfc1 , int 索引1 , string? zfc2 , int 索引2 , int 長度 , CultureInfo? 區域性 , CompareOptions 比較選項 );
public static int Compare ( string? zfc1 , int 索引1 , string? zfc2 , int 索引2 , int 長度 , bool 忽略大小寫 , CultureInfo? 區域性 );
public static int Compare ( string? zfc1 , int 索引1 , string? zfc2 , int 索引2 , int 長度 , StringComparison 比較類型 );
public static int Compare ( string? zfc1 , int 索引1 , string? zfc2 , int 索引2 , int 長度 , bool 忽略大小寫 );
public static int Compare ( string? zfc1 , int 索引1 , string? zfc2 , int 索引2 , int 長度 );

參數

異常

示例

String zfc1 = "machine";
String zfc2 = "device";
String zfc;
int Z結果;

Console . WriteLine ( );
Console . WriteLine ( $"zfc1 = '{zfc1}', zfc2 = '{zfc2}'" );
Z結果 = String . Compare ( zfc1 , 2 , zfc2 , 0 , 2 );
zfc = ( ( Z結果 < 0 ) ? " 小於 " : ( ( Z結果 > 0 ) ? " 大於 " : " 等於 " ) );
Console . Write ( $"在 '{zfc1}' 中子字符串 '{zfc1 . Substring ( 2 , 2 )}'" );
Console . Write ( "{0} " , zfc );
Console . WriteLine ( $"在 '{zfc2}' 中子字符串 '{zfc2 [ .. 2 ] }'" );

以下示例對兩個僅大小寫不同的子字符串進行了兩次比較。第一次比較忽略大小寫，第二次比較則考慮大小寫。

String zfc1 = "machine";
String zfc2 = "MACHINE";
String zfc;
int Z結果;

Console . WriteLine ( );
Console . WriteLine ( $"zfc1 = '{zfc1}', zfc2 = '{zfc2}'" );
Z結果 = String . Compare ( zfc1 , 2 , zfc2 , 2 , 2 , true );
zfc = ( ( Z結果 < 0 ) ? " 小於 " : ( ( Z結果 > 0 ) ? " 大於 " : " 等於 " ) );
Console . Write ( $"在 '{zfc1}' 中子字符串 '{zfc1 [ ..2 ]}'" );
Console . Write ( "{0} " , zfc );
Console . WriteLine ( $"在 '{zfc2}' 中子字符串 '{zfc2 [ .. 2 ] }'" );

Console . WriteLine ( );

Z結果 = String . Compare ( zfc1 , 2 , zfc2 , 2 , 2 , false );
zfc = ( ( Z結果 < 0 ) ? " 小於 " : ( ( Z結果 > 0 ) ? " 大於 " : " 等於 " ) );
Console . Write ( $"在 '{zfc1}' 中子字符串 '{zfc1 [ ..2 ]}'" );
Console . Write ( "{0} " , zfc );
Console . WriteLine ( $"在 '{zfc2}' 中子字符串 '{zfc2 [ ..2 ]}'" );

備註

zfc1 和 zfc2 中的一個或兩個都可以為 null。根據定義，任何字符串（包括 String . Empty）與 null 引用比較時都更大，而兩個 null 引用相互比較時則相等。

可以通過 比較選項 參數進一步指定比較方式，該參數由 System . Globalization . CompareOptions 枚舉的一個或多個成員組成。但是，由於此方法的目的是進行區分區域性的字符串比較，因此 CompareOptions . Ordinal 和 CompareOptions . OrdinalIgnoreCase 值不起作用。

要比較的子字符串在 zfc1 中從 索引1 開始，在 zfc2 中從 索引2 開始。索引1 和 索引2 都是從零開始的；也就是説，zfc1 和 zfc2 中的第一個字符位於位置 0。第一個子字符串的長度等於 zfc1 的長度減去 索引1 再加上 1。第二個子字符串的長度等於 zfc2 的長度減去 索引2 再加上 1。

要比較的字符數量是兩個子字符串長度中的較小值，以及 長度。索引1、索引2 和 長度 參數必須是非負的。

當發現不相等的情況，或者兩個子字符串已完成比較時，比較即終止。不過，如果兩個字符串在其中一個字符串的末尾處比較結果相等，而另一個字符串還有剩餘字符，則擁有剩餘字符的字符串被視為更大。返回值是最後一次比較的結果。

String . CompareOrdinal

通過評估每個字符串中相應字符對象的數值來比較兩個字符串對象。
public static int CompareOrdinal ( string? zfc1 , string? zfc2 );
public static int CompareOrdinal ( string? zfc1 , int 索引1 , string? zfc2 , int 索引2 , int 長度 );

參數

備註：兩個索引以及長度必須同時存在，或同時不存在。

返回值

異常

示例

以下示例對兩個僅大小寫不同的字符串進行序號比較。

string zfc1 = "ABCD";
string zfc2 = "abcd";
string zfcBiao = "";
int zhs結果 = 0;

Console . WriteLine ( "比較每個字符串中對應字符對象的數值。" );
Console . WriteLine ( );
Console . WriteLine ( $"zfc1 = {zfc1}；zfc2 = {zfc2}" );
zhs結果 = string . CompareOrdinal ( zfc1 , zfc2 );
zfcBiao = ( zhs結果 < 0 ) ? "＜" : ( zhs結果 > 0 ) ? "＞" : "＝";
Console . WriteLine ( );
Console . WriteLine ( $"字符串 {zfc1} {zfcBiao} 字符串 {zfc2}" );

string zfc3 = "Hello my sister";
string zfc4 = "Hello my teacher";

Console . WriteLine ( "\n比較每個字符串中前五個字符對象的數值。" );
Console . WriteLine ( );
Console . WriteLine ( $"zfc3 = {zfc3}；zfc4 = {zfc4}" );
zhs結果 = string . CompareOrdinal ( zfc3 , 0 , zfc4 , 0 , 5 );
zfcBiao = ( zhs結果 < 0 ) ? "＜" : ( zhs結果 > 0 ) ? "＞" : "＝";
Console . WriteLine ( );
Console . WriteLine ( $"字符串 {zfc3} {zfcBiao} 字符串 {zfc4}（僅限前五個字符）" );

備註

此方法使用序號排序規則執行區分大小寫的比較。若要使用序號排序規則執行不區分大小寫的比較，請調用 Compare ( String , String , StringComparison ) 方法，並將 comparisonType 參數設置為 StringComparison . OrdinalIgnoreCase。

由於 CompareOrdinal ( String , String ) 是一種靜態方法，因此 zfc1 和 zfc2 可以為 null。如果兩個值均為 null，此方法會返回 0（零），這表示 zfc1 與 zfc2 相等。如果只有其中一個值為 null，此方法會認為非 null 值更大。

若指定 索引1、索引2 和 長度，三個整數不能是負數。

比較的字符數是以下三者中的較小值：zfc1 . Length - 索引1、zfc2 . Length - 索引2，以及 長度。

String . CompareTo

CompareTo方法的兩個重載版本均執行區分區域性和區分大小寫的比較。你不能使用此方法執行不區分區域性或序號比較。為了代碼清晰，我們建議你避免使用 CompareTo 方法，而是調用 Compare 方法。

將此實例與指定對象或字符串進行比較，並返回一個整數，該整數指示此實例在排序順序中是位於指定對象或字符串之前、之後還是同一位置。
public int CompareTo ( object? 比較對象 );
將此實例與指定的對象進行比較，並指出此實例在排序順序中是位於指定的對象之前、之後，還是處於相同位置。
public int CompareTo ( string? 比較對象 );
將此實例與指定的 String 對象進行比較，並指出此實例在排序順序中是位於指定字符串之前、之後，還是處於相同位置。

參數

返回值

異常

實現

CompareTo ( Object )

示例

以下示例將 CompareTo 方法與 Object 一起使用。由於它嘗試將 String 實例與 LEI測試 對象進行比較，該方法會拋出 ArgumentException。

string zfc主 = "123";
object? [ ] DXs =
    [
    new LEI測試 ( ),
    123,
    "我的天哪",
    "123",
    new object ( ),
    null,
    ];

foreach ( var dx in DXs )
    {
    try
        {
            int zhs = zfc主 . CompareTo ( dx );
            Console . WriteLine ( $"比較 '{zfc主}' 和 '{dx}'：{zhs}" );
        }
    catch ( Exception yc )
        {
            Console . WriteLine ( $"發生異常：{yc . Message}" );
        }
    }


public class LEI測試 { }

以下示例使用 CompareTo 方法將當前字符串實例與另一個字符串進行比較。

    string zfc1 = "Goodbye";
    string zfc2 = "Hello";
    string zfc3 = "a small string";
    string zfc4 = "goodbye";

// 將一個字符串與自身進行比較
Console . WriteLine ( FF比較字符串 ( zfc1 , zfc1 ) );

    Console . WriteLine ( FF比較字符串 ( zfc1 , zfc2 ) );
    Console . WriteLine ( FF比較字符串 ( zfc1 , zfc3 ) );

// 將一個字符串與另一個僅在大小寫上有所不同的字符串進行比較
Console . WriteLine ( FF比較字符串 ( zfc1 , zfc4 ) );
    Console . WriteLine ( FF比較字符串 ( zfc4 , zfc1 ) );

static string FF比較字符串 ( string 字符串1 , string 字符串2 )
    {
    // 使用第一個字符串上的 “CompareTo” 方法來比較這些值
    int ZHS比較值 = 字符串1 . CompareTo ( 字符串2 );

    Console . WriteLine ( $"\n{字符串1} . CompareTo ( {字符串2} );" );

    if ( ZHS比較值 == 0 ) // The strings are the same.
        return "這些字符串在排序順序中處於相同位置。";
    else if ( ZHS比較值 < 0 )
        return "第一個字符串在排序順序中位於第二個字符串之前。";
    else
        return "第一個字符串在排序順序中位於第二個字符串之後。";
    }

備註

比較對象（object） 必須是一個字符串對象。

警告：CompareTo 方法主要用於排序或按字母順序排列操作。當方法調用的主要目的是確定兩個字符串是否相等時，不應使用該方法。要確定兩個字符串是否相等，請調用 Equals 方法。

此方法使用當前區域性執行單詞（區分大小寫且區分區域性）比較。

參數為 string 的方法實現了 System . IComparable < T > 接口，並且比 String . CompareTo ( Object ) 方法性能稍好，因為它無需判斷 比較對象 參數是否為必須裝箱的可變值類型，也無需將其參數從 Object 強制轉換為 String。

調用者注意事項

字符集包含可忽略字符。CompareTo ( Object ) 方法在執行區分區域性的比較時，不會考慮這類字符。例如，如果在 .NET Framework 4 或更高版本上運行以下代碼，對 “animal” 和 “ani-mal” （使用軟連字符，即 U+00AD）進行比較會表明這兩個字符串是等效的。

string zfc連字符 = "ani\u00ADmal";
string zfc = "animal";
Console . WriteLine ( $"比較 {zfc連字符} 和 {zfc}：{zfc連字符 . CompareTo ( zfc )}" ); // 0，忽略連字符 \U00AD

要在字符串比較中識別可忽略的字符，請調用 CompareOrdinal ( String , String ) 方法。

string . Concat

連接一個或多個字符串實例，或一個或多個對象實例的值的字符串表示形式。

Concat ( strings )

連接一個 ～ 四個指定的 string 實例。

public static string Concat ( string? zfc0 , string? zfc1 , string? zfc2 , string? zfc3 );
public static string Concat ( string? zfc0 , string? zfc1 , string? zfc2 );
public static string Concat ( string? zfc0 , string? zfc1 );
public static string Concat ( string? zfc0 );

參數

返回值

| 類型 | 説明 |
| string | 按照指定順序連接後的字符串 |

示例

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

const int WORD_SIZE = 4;

// 定義一些由四個字母組成的單詞並對其進行打亂排列
string [ ] CIs = [ "home" , "food" , "game" , "rest" ];
// 定義兩個數組，其長度與每個單詞中的字母數量相同
double [ ] Jians = new double [ WORD_SIZE ];
string [ ] ZiMus = new string [ WORD_SIZE ];
// 初始化隨機數發生器
Random rnd = new ( );

// 攪亂每一個詞
foreach ( string c in CIs )
    {
    for ( int sy = 0 ; sy < c . Length ; sy++ )
        {
        // 向 “Jian” 數組中填充隨機數
        Jians [ sy ] = rnd . NextDouble ( );
        // 為 “ZiMus” 數組分配一個字母
        ZiMus [ sy ] = c [ sy ] . ToString ( );
        }
    // 排序數組
    Array . Sort ( Jians , ZiMus , 0 , WORD_SIZE , Comparer . Default );
    // 顯示被攪亂的詞
    string CI隨機 = String . Concat ( ZiMus [ 0 ] , ZiMus [ 1 ] , ZiMus [ 2 ] , ZiMus [ 3 ] );
    Console . WriteLine ( $"{c} → {CI隨機}" );
    Console . WriteLine ( string . Concat ( "z" ) ); // 無意義的連接

備註

此方法會將 1 ～ 4 個 string 連接起來，並不會添加任何分隔符。

參數只有 zfc0 時，返回值即為 zfc0，通常無意義。

不能沒有參數，且任意參數為 null 時被解釋為 String . Empty（空字符串）。

參數實際可以大於 4 個，此時編譯器會把所有參數存入一個臨時的 object [ ]，再調用 Concat ( object [ ] ) 方法，連接它們。

Concat ( ReadOnlySpan < Char >s )

連接兩個 ～ 四個指定的 ReadOnlySpan < Char > 實例。

public static string Concat ( ReadOnlySpan < Char > c0 , ReadOnlySpan < Char > c1 , ReadOnlySpan < Char > c2 , ReadOnlySpan < Char > c3 );
public static string Concat ( ReadOnlySpan < Char > c0 , ReadOnlySpan < Char > c1 , ReadOnlySpan < Char > c2 );
public static string Concat ( ReadOnlySpan < Char > c0 , ReadOnlySpan < Char > c1 );

參數

返回值

| 類型 | 説明 |
| string | 按照指定順序連接後的字符串 |

示例

ReadOnlySpan<char> zfc1 = "Hello" . AsSpan ( );
ReadOnlySpan<char> zfc2 = " " . AsSpan ( );
ReadOnlySpan<char> zfc3 = "World" . AsSpan ( );
ReadOnlySpan<char> zfc4 = "!" . AsSpan ( );

// 只能連接 2-4 個 ReadOnlySpan<char>
string zfc結果2 = string . Concat ( zfc1 , zfc2 );
string zfc結果3 = string . Concat ( zfc1 , zfc2 , zfc3 );
string zfc結果4 = string . Concat ( zfc1 , zfc2 , zfc3 , zfc4 );

Console . WriteLine ( $"連接 2 個：\"{zfc結果2}\"" );
Console . WriteLine ( $"連接 3 個：\"{zfc結果3}\"" );
Console . WriteLine ( $"連接 4 個：\"{zfc結果4}\"" );

// 超過 4 個需要分步連接
ReadOnlySpan<char> zfc5 = " 你好" . AsSpan ( );
string zfc分步 = string . Concat ( string . Concat ( zfc1 , zfc2 , zfc3 , zfc4 ) , zfc5 );
Console . WriteLine ( $"分步連接 5 個：\"{zfc分步}\"" );

備註

此方法會將 2 ～ 4 個 ReadOnlySpan < Char > 連接起來，並不會添加任何分隔符。

不能沒有參數或只有 1 個參數，也不能超過 4 個參數，但可以重複 Concat。

Concat ( ReadOnlySpan < string >s )

連接指定的 String 範圍的元素。

public static string Concat ( scoped ReadOnlySpan < string? > zfcs);

參數

返回值

| 類型 | 説明 |
| string | zfcs 的串聯元素 |

示例

// 以字符串數組創建的 zfcs
Console . WriteLine ( "=== 示例 1：從字符串數組創建 ===" );
string [ ] Cis = [ "我" , "不" , "認識" , "你" ];
ReadOnlySpan < string? > CiSpan = Cis; // string 要加問號，因為 數組 的元素可能是 null

string zfc數組結果 = string . Concat ( CiSpan );
Console . WriteLine ( zfc數組結果 );

// 以 List<String> 創建 ReadOnlySpan<String>
Console . WriteLine ( "\n=== 示例 2：從 List<string> 創建 ===" );
List<string> LBCis = [ "I" , " " , "like" , " " , "Chinese" ];
ReadOnlySpan <string?> LBSpan = LBCis . ToArray ( ); // 將隊列轉換為數組，並存儲為 ReadOnlySpan
string zfc隊列結果 = string . Concat ( LBSpan );
Console . WriteLine ( zfc隊列結果 );

// 處理 null
Console . WriteLine ( "\n=== 示例 3：處理 null ===" );
string? [ ] LBzfcYnull = [ "C" , null , "#" , null , "!" ];
ReadOnlySpan < string? > LBYnull = LBzfcYnull;
string zfcNull = string . Concat ( LBYnull );
Console . WriteLine ( zfcNull );

// 示例 4：與其他 Concat 重載的性能比較
Console . WriteLine ( "\n=== 示例 4：性能比較 ===" );
const int Z迭代 = 1000000;

// 準備測試數據
string [ ] ShuJu測試 = [ .. Enumerable . Range( 1 , 100 ) . Select ( i => i . ToString ( ) ) ];
ReadOnlySpan<string?> Span測試 = ShuJu測試;
string zfc = "";

// 測試 Concat ( ReadOnlySpan < string > )
var BiaoSpan = System . Diagnostics . Stopwatch . StartNew ( );
for ( int suoyin = 0 ; suoyin < Z迭代 ; suoyin++ )
    {
    zfc = string . Concat ( Span測試 );
    }
BiaoSpan . Stop ( );
Console . WriteLine ( $"Concat ( ReadOnlySpan < string > )：{BiaoSpan . ElapsedMilliseconds} 毫秒" );

// 測試 Concat ( params string [ ] )
zfc = "";
var BiaoShuZu = System . Diagnostics . Stopwatch . StartNew ( );
for ( int suoyin = 0 ; suoyin < Z迭代 ; suoyin++ )
    {
    zfc = string . Concat ( ShuJu測試 );
    }
BiaoShuZu . Stop ( );
Console . WriteLine ( $"Concat ( params string [ ] )：{BiaoShuZu . ElapsedMilliseconds} 毫秒" );

// 示例 5：結合 LINQ 使用
Console . WriteLine ( "\n=== 示例 5：結合 LINQ 使用 ===" );
string [ ] zfc水果s = [ "Apple" , "Banana" , "Cherry" , "Date" , "Elderberry" ];

// 使用 LINQ 篩選後轉換為 ReadOnlySpan<string>
var Ci水果大於5 = zfc水果s . Where ( f => f . Length > 5 ) . ToArray ( );
ReadOnlySpan<string?> Chang水果Span = Ci水果大於5;

string zfc水果 = string . Concat ( Chang水果Span );
Console . WriteLine ( zfc水果 ); // 輸出：BananaCherryElderberry

Concat ( 對象s )

創建或連接指定 對象（或 對象s）的字符串表示形式。

public static string Concat ( object? dx0 );
public static string Concat ( object? dx0 , object? dx1 );
public static string Concat ( object? dx0 , object? dx1 , object? dx2 );
public static string Concat ( params object? [ ] dxs );

參數

返回值

異常

示例

下例演示了 Concat 方法連接 object 數組中的元素：

LEI測試1 cs1 = new ( );
LEI測試2 cs2 = new ( );
int zhs = 128;
string zfc = "兔子";

object [ ] dxs = [ cs1 , zhs , cs2 , zfc ];
Console . WriteLine ( string . Concat ( dxs ) );

class LEI測試1
    {
    public override string ToString ( )
        {
        return "這是測試 1"; // 表明可以通過 ToString ( ) 來改變類的字符串表示形式
        }
    }

class LEI測試2
    {
    // 故意不寫 ToString ( )
    }

以下示例演示了 Concat 方法。

object dx = "我";
object [ ] dxs = [ "我" , "喜" , "歡" , "你" ];

Console . WriteLine ( "連接 1、2 和 3 個對象：" );
Console . WriteLine ( $"1 ）{string . Concat ( dx )}" );
Console . WriteLine ( $"2 ）{string . Concat ( dx , dx )}" );
Console . WriteLine ( $"3 ）{string . Concat ( dx , dx , dx )}" );

Console . WriteLine ( "\n連接 4 和 5 個對象（使用可變長度的參數列表，由於 Concat 只有最大三個參數，只有臨時存儲為一個 object [ ]）：" );
Console . WriteLine ( $"4 ）{string . Concat ( dx , dx , dx , dx )}" );
Console . WriteLine ( $"5 ）{string . Concat ( dx , dx , dx , dx , dx )}" );

Console . WriteLine ( "\n連接 4 個元素的 object 數組：" );
Console . WriteLine ( $"6 ）{string . Concat ( dxs )}" );

備註

Concat ( dx ) 方法 和 Concat ( dxs ) 方法通過調用 dx 或 dxs 的元素的無參數的 ToString 方法，將 dx 或 dxs 的元素表示為字符串。多個對象之間不會添加任何分隔符。

任意 null 參數或元素被表示為 String . Empty，但 dxs 不能為 null。

當使用多個參數形式時，任一參數可為 object [ ]，但不會連接其成員，而是表示為類似 System . String [ ] 的形式。

Concat ( ReadOnlySpan < object >s )

連接指定的 Object 範圍的元素。

public static string Concat ( scoped ReadOnlySpan < object? > dxs);

參數

返回值

| 類型 | 説明 |
| string | zfcs 的串聯元素 |

Concat ( IEnumerable < String > )

拼接類型為 String 的構造的 IEnumerable < T > 集合的成員。
public static string Concat ( System . Collections . Generic . IEnumerable < string? > values );

Parameters 參數

返回值

示例

以下示例使用埃拉託斯特尼篩法計算小於或等於 1000 的質數。它將結果分配給一個類型為 String 的 List < T > 對象，然後將該對象傳遞給 Concat ( IEnumerable < String > ) 方法。

using static System . Math;

int 上限 = 1000;
IEnumerable < string > ZhiShus = FF獲取質數 ( 上限 );
Console . WriteLine ( $"上限為 {上限} 的質數：\n{string . Concat (ZhiShus )}" );

static IEnumerable < string > FF獲取質數 ( int 上限 )
    {
    Array Zhis = Array . CreateInstance ( typeof ( int ) , [上限 - 1] , [ 2 ] );

    for ( int suoyin = Zhis . GetLowerBound ( 0 ) ; suoyin <= ( int ) Ceiling ( Sqrt ( Zhis . GetUpperBound ( 0 ) ) ) ; suoyin++ )
        {

        if ( ( int? ) Zhis . GetValue ( suoyin ) == 1 ) continue;

        for ( int Z倍增器 = suoyin ; Z倍增器 <= 上限 / 2 ; Z倍增器++ )
            if ( suoyin * Z倍增器 <= 上限 )
                Zhis . SetValue ( 1 , suoyin * Z倍增器 );
        }

    List < string > ZhiShus = [ ];
    for ( int suoyin = Zhis . GetLowerBound ( 0 ) ; suoyin <= Zhis . GetUpperBound ( 0 ) ; suoyin++ )
        if ( ( int? ) Zhis . GetValue ( suoyin ) == 0 )
            ZhiShus . Add ( $"{suoyin}，" );

    return ZhiShus;
    }

備註

該方法會連接 IEnumerable < string > 中的每個對象，且不添加任何分隔符。若要在 IEnumerable < string > 的每個成員之間指定分隔符，請調用 Join ( String , IEnumerable < String > ) 方法。

空字符串用於替代 IEnumerable < string > 中的任何空元素。

如果 IEnumerable < string > 是一個空的 IEnumerable ( Of String )，則該方法返回 String . Empty。如果 IEnumerable < string > 為 null，則該方法會引發 ArgumentNullException 異常。

Concat ( IEnumerable < String > ) 是一個便捷方法，它允許你連接 IEnumerable ( Of String ) 集合中的每個元素，而無需先將這些元素轉換為字符串數組。它在語言集成查詢（LINQ）查詢表達式中尤其有用。以下示例將一個 List ( Of String ) 對象（其中包含字母表的大寫字母或小寫字母）傳遞給一個 lambda 表達式，該表達式會篩選出等於或大於特定字母（在本示例中為 “M” ）的字母。Enumerable . Where 方法返回的 IEnumerable ( Of String ) 集合被傳遞給 Concat ( IEnumerable < String > ) 方法，以將結果顯示為單個字符串。

string zfc = string . Concat ( FF獲取字母表 ( true ) . Where
                                               ( zm => zm . CompareTo ( "M" ) >= 0 ) );
Console . WriteLine ( zfc );

static List < string > FF獲取字母表 ( bool 大寫 )
    {
    List < string > zmb = [ ];
    int ZDX = 大寫 ? 65 : 97;
    for ( int zm = 0 ; zm <= 25 ; zm++ )
        zmb . Add ( ( ( char ) ( ZDX + zm ) ) . ToString ( ) );
    return zmb;
    }

String . Contains 方法

返回一個 Boolean，指示指定的 字符（Char，包括 StringComparison 選項）或者 字符串（String，包括 StringComparison 選項）是否包含在實例中。

public bool Contains ( Char 字符 );
public bool Contains ( Char 字符 , StringComparison 選項 );
public bool Contains ( string 字符串 );
public bool Contains ( string  字符串 , StringComparison 選項 );

參數

返回值

異常

示例

string zfc主 = "The quick brown fox jumps over the lazy dog";
char zfD = 'D' , zfX = 'd';
string zfc = "fox";

bool Ber包含D = zfc主 . Contains ( zfD , StringComparison . CurrentCulture );
bool Ber包含d = zfc主 . Contains ( zfX );
bool Ber包含fox = zfc主 . Contains  ( zfc );

if ( Ber包含D )
    { Console . WriteLine ( $"在 {zfc主} 中包含 {zfD}：{zfc主 . IndexOf ( zfD ) + 1}" ); }
else
    { Console . WriteLine ( $"在 {zfc主} 中包含 {zfD}：{Ber包含D}" ); }

if ( Ber包含d )
    { Console . WriteLine ( $"在 {zfc主} 中包含 {zfX}：{zfc主 . IndexOf ( zfX ) + 1}" ); }
else
    { Console . WriteLine ( $"在 {zfc主} 中包含 {zfX}：{Ber包含d}" ); }

if ( Ber包含fox )
    { Console . WriteLine ( $"在 {zfc主} 中包含 {zfc}：{zfc主 . IndexOf ( zfc ) + 1}" ); }
else
    { Console . WriteLine ( $"在 {zfc主} 中包含 {zfc}：{Ber包含fox}" ); }

備註

此方法執行序號（區分大小寫且不區分區域性）比較。搜索從該字符串的第一個字符位置開始，一直持續到最後一個字符位置。

要執行區分區域性或不區分大小寫的序號比較：

• 在 .NET Core 2.1 及更高版本上：請使用 Contains ( String , StringComparison ) 重載。

• 在 .NET Framework 上：創建一個自定義方法。下面的示例説明了一種此類方法。它定義了一個 BER包含 擴展方法，該方法包含一個 StringComparison 參數，並指出在使用指定的字符串比較形式時，字符串是否包含子字符串。

  string zfc = "我是一個 AI！";
  string zfcAI = "ai";
  StringComparison bijiao = StringComparison . CurrentCulture;
  Console . WriteLine ( $"在 {zfc} 中包含 {zfcAI}（{bijiao}）：{LEI字符串 . BER包含 ( zfc , zfcAI , bijiao )}" );
  
  bijiao = StringComparison . CurrentCultureIgnoreCase;
  Console . WriteLine ( $"在 {zfc} 中包含 {zfcAI}（{bijiao}）：{LEI字符串 . BER包含 ( zfc , zfcAI , bijiao )}" );
  
  public static class LEI字符串
    {
    public static bool BER包含 ( this string 我 , string 包含 , StringComparison 比較選項 )
        {
        if (  string . IsNullOrEmpty ( 包含 ) )
            {
            return true;
            }
        else if ( !Enum . IsDefined ( 比較選項 ) )
            {
            throw new ArgumentException ( "比較選項不是一個 StringComparison 選項" , nameof ( 比較選項 ) );
            }
        return 我 . Contains ( 包含 , 比較選項 );
        }
    }

  String . CopyTo

  CopyTo ( Span < Char > )

  將此字符串的內容複製到目標範圍中。
  public void CopyTo ( Span < char > 目標 );

  參數

  目標	類型	註解
  目標	Span < Char >	欲將字符串複製到的範圍 目標

  異常

  異常	説明
  ArgumentException	目標 範圍 . Length < 實例 . Length

  示例

  // 原始字符串
  string zfc原始 = "Hello, World!";
  Console . WriteLine ( $"原始字符串：'{zfc原始}'，長度：{zfc原始 . Length}" );
  
  // 創建一個"容器"（字符數組）來存放複製的內容
  char [ ] 字符容器 = new char [ 15 ]; // 可以裝 15 個字符
  Console . WriteLine ( $"字符容器大小：{字符容器 . Length} 個字符位置" );
  
  // 將字符數組轉換為"操作範圍"（Span<char>）
  // 想象成劃定一個可以操作的區域
  Span<char> 操作範圍 = 字符容器.AsSpan();
  
  // 執行復制：把原始字符串放到操作範圍內
  zfc原始 . CopyTo ( 操作範圍 );
  
  // 查看複製結果
  Console . WriteLine ( $"\n複製完成！" );
  Console . WriteLine ( $"操作範圍長度：{操作範圍 . Length}" );
  Console . WriteLine ( $"操作範圍內的內容：‘{new string ( 操作範圍 )}’" );
  
  // 檢查字符容器的狀態
  Console . WriteLine ( $"\n字符容器的最終狀態：" );
  Console . WriteLine ( $"字符容器中的內容：'{new string ( 字符容器 )}'" );
  Console . WriteLine ( $"字符容器中實際使用的位置：{zfc原始 . Length} 個" );
  Console . WriteLine ( $"字符容器中空閒的位置：{字符容器 . Length - zfc原始 . Length} 個" );

  CopyTo ( Int32 , Char [ ] , Int32 , Int32 )

  從該實例的指定位置複製指定數量的字符到 Unicode 字符數組的指定位置。
  public void CopyTo ( int 源索引 , char [ ] 目標 , int 目標索引 , int 字符數 );

  參數

  參數	類型	説明
  源索引	int	字符串實例欲複製的起始索引
  目標	char [ ]	欲存放複製字符的 char 數組
  目標索引	int	char 數組中存放複製字符的起始索引
  字符數	int	實例中複製的字符數

  異常

  異常	説明
  ArgumentNullException	目標 為 null
  ArgumentOutOfRangeException	源索引、目標索引 和 字符數 為負數；源索引（實例）、目標索引（目標）未標識有效的索引；字符數 大於 實例（目標） 自 源索引（目標索引） 至 實例（目標） 末尾的長度

  示例

  // 將一組字符嵌入到字符串中
  string zfc源 = "changed";
  char [ ] zf目標 = { 'T', 'h', 'e', ' ', 'i', 'n', 'i', 't', 'i', 'a', 'l', ' ', 'a', 'r', 'r', 'a', 'y' };
  
  // 輸出 Char 數組
  Console . WriteLine ( zf目標 );
  
  // 將源字符串嵌入到 zf目標 字符串中
  zfc源 . CopyTo ( 0 , zf目標 , 4 , zfc源 . Length );
  
  // 輸出生成的數組
  Console . WriteLine ( zf目標 );
  
  zfc源 = "A different string";
  
  // 僅將 zfc源 的一部分嵌入到 zf目標 中
  zfc源 . CopyTo ( 2 , zf目標 , 3 , 9 );
  
  // 輸出生成的數組
  Console . WriteLine ( zf目標 );

  備註

  此方法從當前實例的 源索引 位置複製 字符數 個字符到 目標 Char 數組的 目標索引 位置。此方法不會調整 目標 Char 數組的大小；該數組必須有足夠數量的元素來容納複製的字符，否則此方法將拋出 ArgumentOutOfRangeException 異常。

源索引 和 目標索引 是從零開始的。

String . Create

Create ( IFormatProvider , Span < Char > , DefaultInterpolatedStringHandler )

通過使用指定的提供程序來控制指定插值字符串的格式，從而創建一個新字符串。
public static string Create ( IFormatProvider? geshitigongzhe , Span < char > chushihuanchongqu , ref System . Runtime . CompilerServices . DefaultInterpolatedStringHandler chulichengxu );

參數

返回值

示例

Console . WriteLine ( "=== String . Create 與字符串插值結合示例 ===\n" );

Span < char > 緩衝區 = stackalloc char [ 100 ];
var 格式提供器 = CultureInfo . InvariantCulture;
double 價格 = 99.99;
string 產品 = "羽絨服";

string 結果 = string . Create ( 格式提供器 , 緩衝區 , $"{產品} → 價格羽絨服：{價格:C}");
Console . WriteLine ( $"結果：{結果}" );
Console . WriteLine ( $"緩衝區使用長度：{結果 . Length}\n" );

Console . WriteLine ( "=== 羽絨服價格標籤生成器 ===\n" );

// 商品信息
string 商品名稱 = "羽絨服";
double 價格羽絨服 = 299.99;
string 顏色 = "黑色";
int 尺碼 = 180;

// 方法1：傳統字符串拼接
string 傳統方式 = 商品名稱 + "（" + 顏色 + "，" + 尺碼 + "碼）價格羽絨服：" + 價格羽絨服 . ToString ( "C" , CultureInfo . InvariantCulture );
Console . WriteLine ( "傳統方式：" );
Console . WriteLine ( 傳統方式 + "\n" );

// 方法2：字符串插值
string 插值方式 = $"{商品名稱}（{顏色}，{尺碼}碼）價格羽絨服：{價格羽絨服:C}";
Console . WriteLine ( "字符串插值：" );
Console . WriteLine ( 插值方式 + "\n" );

// 方法3：高性能方式（stackalloc + String . Create）
Console . WriteLine ( "高性能方式（stackalloc + String . Create）：" );

// 在棧上分配內存（就像臨時的筆記本）
Span<char> 臨時緩衝區 = stackalloc char [ 100 ];

// 創建格式化提供器（統一的格式規則）
var 格式規則 = CultureInfo . InvariantCulture;

// 使用 String.Create 創建最終字符串
string 高性能結果 = string . Create(
            格式規則,                // 使用的格式規則
            臨時緩衝區,              // 臨時存放的地方
            $"{商品名稱}（{顏色}，{尺碼}碼）價格羽絨服：{價格羽絨服:C}"  // 要生成的內容
        );

Console . WriteLine ( 高性能結果 );
Console . WriteLine ( $"使用內存大小：{高性能結果 . Length} 個字符\n" );

// 方法4：使用 ArrayPool（可重用的內存池）
Console . WriteLine ( "環保方式（ArrayPool + String . Create）：" );

// 從內存池租用一塊內存
char [ ] 租用的緩衝區 = ArrayPool < char > . Shared . Rent ( 100 );

try
    {
    // 使用租用的內存創建字符串
    string 環保結果 = string . Create (
                格式規則,
                租用的緩衝區 . AsSpan ( ),
                $"{商品名稱}（{顏色}，{尺碼}碼）價格羽絨服：{價格羽絨服:C}"
            );

    Console . WriteLine ( 環保結果 );
    }
finally
    {
    ArrayPool<char> . Shared . Return ( 租用的緩衝區 );
    }

Create ( IFormatProvider , DefaultInterpolatedStringHandler )

通過使用指定的提供程序來控制指定插值字符串的格式，從而創建一個新字符串。
public static string Create ( IFormatProvider? geshitigongzhe , ref System . Runtime . CompilerServices . DefaultInterpolatedStringHandler chulichengxu );

參數

返回值

示例

// 簡單的商品信息
string ZFC水果 = "香蕉";
decimal SJZ價格 = 2.50m;

// 使用中文格式
var QY中國 = new CultureInfo ( "zh-CN" );

// 一步創建字符串
string message = string . Create (
            QY中國,
            $"{ZFC水果} 的價格是：{SJZ價格:C}"
        );

Console . WriteLine ( message );
// 輸出：香蕉 的價格是：￥2.50

Create < TState > ( Int32 , TState , SpanAction < Char , TState > )

創建一個具有特定長度的新字符串，並在創建後使用指定的回調函數對其進行初始化。
public static string Create < TState > ( int 長度 , TState 狀態 , System . Buffers . SpanAction < char , TState > 操作 ) where TState : allows ref 結構;

參數

返回值

示例

// 示例 1：創建重複字符的字符串
string 結果1 = string . Create ( 5 , 'A' , ( span , 字符 ) => 
    {
        for ( int i = 0 ; i < span . Length ; i++ )
            span [ i ] = 字符;
    } );
Console . WriteLine ( $"重複字符：{結果1}" );  // 輸出：AAAAA

// 示例 2：格式化產品信息
var 產品數據 = new { 名稱 = "筆記本電腦" , 價格 = 5999 };
string 結果2 = string . Create ( 20 , 產品數據 , ( span , 數據 ) => 
    {
        $"{數據 . 名稱} 價格 {數據 . 價格}元" . AsSpan ( ) . CopyTo ( span );
    } );
Console . WriteLine ( $"產品信息：{結果2}" );  // 輸出：筆記本電腦 價格 5999元

// 示例 3：數字格式化
string 結果3 = string . Create ( 10 , 123456 , ( span , 數字 ) => 
    {
        數字 . ToString ( "N0" ) . AsSpan ( ) . CopyTo ( span );
    } );
Console . WriteLine ( $"千分位格式：{結果3}" );  // 輸出：123,456

備註

傳遞給 action 的 操作範圍 的初始內容是未定義的。因此，委託方有責任確保跨度的每個元素都被賦值。否則，生成的字符串可能包含隨機字符。

為支持互操作場景，基礎緩衝區保證至少比操作回調的 操作範圍 所表示的大 1。這個額外的索引代表 null 終止符，且如果寫入的話，這是唯一受支持的值。寫入 null 終止符以外的任何值都會損壞字符串，且被視為未定義行為。

String . StartWith 和 String . EndWith

確定此字符串實例的結尾或起始是否與指定的字符或字符串匹配。

public bool EndsWith ( char 值 );
public bool EndsWith ( string 值 );
public bool EndsWith ( string 值 , StringComparison 比較類型 );
public bool EndsWith ( string 值 , bool BER忽略大小寫 , System . Globalization . CultureInfo? 區域性 );
public bool StartsWith ( char 值 );
public bool StartsWith ( string 值 );
public bool StartsWith ( string 值 , StringComparison 比較類型 );
public bool StartsWith ( string 值 , bool BER忽略大小寫 , System . Globalization . CultureInfo? 區域性 );

參數

返回值

異常

示例

參數為字符

string zfc = "hello world";
char [ ] ZFs = [ 'd' , 'H' , 'h' ];

foreach ( char z in ZFs )
    {
    Console . WriteLine ( $"{zfc} 起始於 ‘{z}’ 嗎？ → {( zfc . StartsWith ( z ) ? "是" : "否" )}\n" );
    }

foreach ( char z in ZFs )
    {
    Console . WriteLine ( $"{zfc} 結束於 ‘{z}’ 嗎？ → {( zfc . EndsWith ( z ) ? "是" : "否" )}\n" );
    }

string zfcKong = "";
foreach ( char z in ZFs )
    {
    Console . WriteLine ( $"空字符串起始於 ‘{z}’ 嗎？ → {( zfcKong . StartsWith ( z ) ? "是" : "否" )}" );
    Console . WriteLine ( $"空字符串結束於 ‘{z}’ 嗎？ → {( zfcKong . EndsWith ( z ) ? "是" : "否" )}" );
    }

string? zfcNull = null;
char zfh = 'h';
Console . WriteLine ( );
// 使用 null 條件運算符 ?.
bool? berQiShi = zfcNull? . StartsWith ( zfh );
bool? berJieShu = zfcNull? . EndsWith ( zfh );

Console . WriteLine ( $"null字符串起始於 ‘{zfh}’ 嗎？ → {( berQiShi . HasValue ? ( berQiShi . Value ? "是" : "否" ) : "字符串為 null" )}" );
Console . WriteLine ( $"null字符串結束於 ‘{zfh}’ 嗎？ → {( berJieShu . HasValue ? ( berJieShu . Value ? "是" : "否" ) : "字符串為 null" )}" );

參數為字符串

String[] zfcs = { "我是一個兵！" , "我不是一個人。" , "我是三個人。" , "我不在家" , "家裏沒人" , "我。" , "" };
foreach ( var zfc in zfcs )
    {
    bool BER結束於人 = zfc . EndsWith ( "人。" );
    Console . WriteLine ( $"‘{zfc}’ 結束於“人。”：{BER結束於人}" );
    }

Console . WriteLine ( );
foreach ( var zfc in zfcs )
    {
    bool BER起始於我是 = zfc . StartsWith ( "我是" );
    Console . WriteLine ( $"‘{zfc}’ 起始於“我是”：{BER起始於我是}" );
    }

Console . WriteLine ( );
foreach ( var zfc in zfcs )
    {
    bool BER起始於我句號 = zfc . StartsWith ( "我。" );
    Console . WriteLine ( $"‘{zfc}’ 起始於“我。”：{BER起始於我句號}" );
    bool BER結束於我句號 = zfc . EndsWith ( "我。" );
    Console . WriteLine ( $"‘{zfc}’ 結束於“我。”：{BER結束於我句號}" );
    }

以下示例定義了一個 FF去除結束標記 方法，該方法使用 EndsWith ( String ) 方法從一行的末尾移除 HTML 結束標籤。請注意，FF去除結束標記 方法會被遞歸調用，以確保移除該行末尾的多個 HTML 結束標籤。

// 處理包含 HTML 標籤的輸入文件。
// 此示例會檢查行尾處的多個標籤，而非僅僅刪除最後一個標籤。
// 注意：HTML 標記總是以大於號（>）結尾。

string [ ] ZFC源 = [ "<b>這是粗體字</b>", "<H1>這是大文本</H1>",
                "<b><i><font color=green>這是多個標誌的</font></i></b>",
                "<b>這是有<i>嵌套的</i>標誌。</b>",
                "這一行僅僅以一個 “>” 符號結尾，不應對其進行修改。>" ];

Console . WriteLine ( "以下列出了在去除尾部之前所包含的項目：" );
Console . WriteLine ( "-----------------------------------------------------------------" );

// 輸出初始的字符串數組
foreach ( string z in ZFC源 )
    Console . WriteLine ( z );

Console . WriteLine ( );

Console . WriteLine ( "以下列出了去除尾部後剩餘的項目：" );
Console . WriteLine ( "----------------------------------------------------------------" );

// 輸出字符串數組
foreach ( var z in ZFC源 )
    Console . WriteLine ( FF去除結束標記 ( z ) );

static string FF去除結束標記 ( string 項目 )
    {
    if ( string . IsNullOrEmpty ( 項目 ) )
        return 項目;

    string zfc處理結果 = 項目;
    bool ber有修改 = true;

    while ( ber有修改 )
        {
        ber有修改 = false;
        string zfc修剪後的結果 = zfc處理結果 . TrimEnd ( );

        // 1. 首先檢查是否有完整的 HTML 結束標記 </tag>
        int Z結束標記開始位置 = zfc修剪後的結果 . LastIndexOf ( "</" );
        if ( Z結束標記開始位置 >= 0 )
            {
            string zfc可能的標記 = zfc修剪後的結果 [  Z結束標記開始位置 .. ];

            // 檢查這是否是一個完整的結束標記
            int Z結束符位置 = zfc可能的標記 . IndexOf ( '>' );
            if ( Z結束符位置 > 2 ) // 確保有標記名
                {
                string zfc標記名 = zfc可能的標記 [  2 .. Z結束符位置  ];

                // 驗證標記名是否有效（只能包含字母、數字、下劃線、連字符和冒號）
                if ( IsValidTagName ( zfc標記名 ) )
                    {
                    // 這是一個有效的 HTML 結束標記，去除它
                    zfc處理結果 = zfc修剪後的結果 [ .. Z結束標記開始位置 ] . TrimEnd ( );
                    ber有修改 = true;
                    continue;
                    }
                }
            }

        // 2. 如果沒有找到完整的結束標記，檢查是否有單獨的 ">"
        if ( zfc修剪後的結果 . EndsWith ( '>' ) )
            {
            // 檢查這個 ">" 是否是 HTML 標記的一部分
            if ( IsHtmlTagDelimiter ( zfc修剪後的結果 ) )
                {
                // 這可能是一個不完整的 HTML 標記，去除這個 ">"
                zfc處理結果 = zfc修剪後的結果 [ .. ^1 ] . TrimEnd ( );
                ber有修改 = true;
                }
            else
                {
                // 這是一個正常的 ">" 字符，保留它
                break;
                }
            }
        else
            {
            break;
            }
        }

    return zfc處理結果;
    }

// 驗證 HTML 標記名是否有效
static bool IsValidTagName ( string tagName )
    {
    if ( string . IsNullOrEmpty ( tagName ) )
        return false;

    // HTML標記名規則：
    // 1. 不能以數字開頭
    // 2. 只能包含字母、數字、下劃線、連字符和冒號
    if ( char . IsDigit ( tagName [ 0 ] ) )
        return false;

    foreach ( char c in tagName )
        {
        if ( !char . IsLetterOrDigit ( c ) && c != '_' && c != '-' && c != ':' )
            return false;
        }

    return true;
    }

// 檢查 ">" 是否是 HTML 標記的分隔符
static bool IsHtmlTagDelimiter ( string text )
    {
    if ( text . Length < 2 || !text . EndsWith ( '>' ) )
        return false;

    char previousChar = text[ ^2 ];

    // 如果 ">" 前面是字母、數字、下劃線、連字符或冒號，則可能是標記的一部分
    return char . IsLetterOrDigit ( previousChar ) || previousChar == '_' || previousChar == '-' || previousChar == ':';
    }

參數包括布爾值和文化信息

以下示例判斷一個字符串是否出現在另一個字符串的末尾。EndsWith 方法被多次調用，調用時分別使用了區分大小寫、不區分大小寫的方式，以及會影響搜索結果的不同區域性設置。

string msg1 = "在字符串 \"{1}\" 中搜索目標字符串 \"{0}\".\n";
string msg2 = "使用 {0} - \"{1}\" 文化：";
string msg3 = "  要搜索的字符串以目標字符串結尾：{0}";
bool jieguo;
CultureInfo quyu;

// 定義要搜索的目標字符串。
// U+00c5 = 帶圓環的拉丁大寫字母 A
string capitalARing = "\u00c5";

// 定義要搜索的字符串。
// 組合字符拉丁小寫字母 A 和組合圓環（U+0061, U+030a）的結果在語言上等同於字符
// 帶圓環的拉丁小寫字母A（U+00e5）。
string xyzARing = "xyz" + "\u0061\u030a";

// 顯示要搜索的字符串和要搜索的目標字符串。
Console . WriteLine ( msg1 , capitalARing , xyzARing );

// 使用英語-美國文化進行搜索。
quyu = new CultureInfo ( "en-US" );
Console . WriteLine ( msg2 , quyu . DisplayName , quyu . Name );

Console . WriteLine ( "區分大小寫：" );
jieguo = xyzARing . EndsWith ( capitalARing , false , quyu );
Console . WriteLine ( msg3 , jieguo );

Console . WriteLine ( "不區分大小寫：" );
jieguo = xyzARing . EndsWith ( capitalARing , true , quyu );
Console . WriteLine ( msg3 , jieguo );
Console . WriteLine ( );

// 使用瑞典語-瑞典文化進行搜索。
quyu = new CultureInfo ( "sv-SE" );
Console . WriteLine ( msg2 , quyu . DisplayName , quyu . Name );

Console . WriteLine ( "區分大小寫：" );
jieguo = xyzARing . EndsWith ( capitalARing , false , quyu );
Console . WriteLine ( msg3 , jieguo );

Console . WriteLine ( "不區分大小寫：" );
jieguo = xyzARing . EndsWith ( capitalARing , true , quyu );
Console . WriteLine ( msg3 , jieguo );

備註

若指定參數為 Char，此 Char 不能為 null，此方法執行序號（區分大小寫且不區分區域性）比較。若 實例 為 null，則任意 Char 均返回 false；若 實例 為 Empty，則任意 Char 均返回 false。

若指定參數為 String，此方法執行序號（區分大小寫且區分區域性）比較，實例 不能為 null。此方法將 zfc 與此實例起始或末尾長度與 zfc 相同的子字符串進行比較，並返回它們是否相等的指示。要相等，zfc 必須是對此同一實例的引用，或者與該實例的起始或末尾匹配。對於任意非空實例，zfc 為 Empty 時均返回 false；空實例 則返回 true。

正如《使用字符串的最佳實踐》中所解釋的，我們建議您避免調用那些替換默認值的字符串比較方法，而是調用需要明確指定參數的方法。要使用當前區域性的字符串比較規則來確定某個字符串是否以特定子字符串結尾，請通過為其 比較選項 參數傳遞 CurrentCulture 值，調用 EndsWith ( String , StringComparison ) 或 StartsWith ( String , StringComparison ) 方法重載，以明確表明您的意圖。如果您不需要具備語言感知能力的比較，可以考慮使用 Ordinal。

當指定 比較選項 時，將 zfc 參數與該 實例 起始或末尾的子字符串進行比較，並返回一個指示它們是否相等的值。要使兩者相等，zfc 必須是對該 實例 本身的引用、必須是空字符串（""），或者必須與該字符串的起始或末尾匹配。方法執行的比較類型取決於 比較選項 參數的值。

當指定 區分大小寫 和 區域性 時，將 zfc 參數與該 實例 起始或末尾的子字符串進行比較，並返回一個指示它們是否相等的值。要使兩者相等，zfc 必須是對該 實例 本身的引用，或者必須與該字符串的起始或末尾匹配。方法執行的比較類型取決於 區分大小寫 和 區域性 參數的值。

String . EnumerateRunes

從該字符串返回 Rune（符文）的枚舉。
public System . Text . StringRuneEnumerator EnumerateRunes ( );

返回值

備註

枚舉中的無效序列由 Rune . ReplacementChar 表示。

String . Equals

判斷兩個字符串對象是否具有相同的值。

重載

public override bool Equals ( object? dx );
public bool Equals ( string? zfc );
public static bool Equals ( string? zfc1 , string? zfc2 );
public bool Equals ( string? zfc , StringComparison 比較選項 );

參數

返回值

實現

Equals ( T )

異常

示例

下例演示了 實例 . Equals ( dx ) 方法，説明了任意非 String 對象均與示例不等。

string zfc123 = "123";
int zhs123 = 123;
object dxShuZi = "123";
DateTime RiQi = new ( 2023 , 11 , 12 );

// 比較字符串和整數
bool berJieGuo1 = zfc123 . Equals ( zhs123 );
Console . WriteLine ( berJieGuo1 );
// 實際比較的是 "123" 和 123，返回 false

// 比較字符串和日期時間  
bool berJieGuo2 = zfc123 . Equals ( RiQi );
Console . WriteLine ( berJieGuo2 );
// 實際比較的是 "123" 和 "2023/11/12 00:00:00"，返回 false

bool berJieGuo3 = zfc123 . Equals (zhs123 . ToString ( ) );
Console . WriteLine ( berJieGuo3 );
// 實際比較的是 "123" 和 "123"，返回 true

bool berJieGuo4 = zfc123 . Equals ( null );
Console . WriteLine ( berJieGuo4 );
// 實際比較的是 "123" 和 null 對象，返回 false

bool berJieGuo5 = zfc123! . Equals ( dxShuZi );
Console . WriteLine ( berJieGuo5 );
// 實際比較的是 "123" 和 "123"，返回 true

以下示例演示了 Equals 方法。它將首字母大寫的單詞 “File” 與其等效單詞、小寫等效形式、大寫等效形式以及一個包含拉丁小寫無點 I（U+0131）而非拉丁小寫 I（U+0069）的單詞進行比較。由於 Equals ( String ) 方法執行序號比較，因此只有與完全相同的單詞進行比較時才會返回 true。

Console . OutputEncoding = System . Text . Encoding . UTF8;
string zfcCi = "File";
string [ ] zfcCis = [zfcCi . ToLower ( ) , zfcCi , zfcCi . ToUpper ( ) , "Fıle" ];
foreach ( string c in zfcCis )
    {
    if ( zfcCi . Equals ( c ) )
        Console . WriteLine ( $"{zfcCi} = {c}" );
    else
        Console . WriteLine ( $"{zfcCi} {'\u2260'} {c}" );
    }

下面的示例創建了一個字符串數組，其中包含一個大寫的 “I”、一個小寫的 “i” 和一個無點的 “ı”。然後，它調用 Equals ( String , StringComparison ) 方法，使用每個可能的 StringComparison 枚舉值來比較它們。

// 定義一個字符串數組，其中包含以下三個 “i” 字符：
//      U+0069，U+0131，and U+0049。
string [ ] zfc3Is = { "i" , "ı" , "I" };
// 定義一個表示字符串比較類型（StringComparison 類型）的對象
Type zfc比較類型 = typeof ( StringComparison );

// 顯示當前的文本格式（用於進行具有文化敏感性的字符串比較）
Console . WriteLine ( $"當前區域性是：{CultureInfo . CurrentCulture . Name}。\n" );

Console . OutputEncoding = Encoding . UTF8; // 設置控制枱的顯示編碼，否則 ‘ı’ 無法顯示（顯示為 ？）

// 使用每個 StringComparison 成員來進行比較操作
foreach ( string zfc比較名 in Enum . GetNames ( zfc比較類型 ) )
    {
    StringComparison bj = ( StringComparison ) Enum . Parse ( zfc比較類型 , zfc比較名 );
    Console . WriteLine ( $"使用 {bj} 比較：" );
    // 比較字符數組中的每個字符
    for ( int zhs索引 = 0 ; zhs索引 <= 1 ; zhs索引++ )
        {
        string ZF實例 = zfc3Is [ zhs索引 ];
        for ( int zhs內索引 = zhs索引 + 1 ; zhs內索引 <= zfc3Is . GetUpperBound ( 0 ) ; zhs內索引++ )
            {
            string ZF另一個 = zfc3Is [ zhs內索引 ];
            Console . WriteLine ( $"{ZF實例}（U+{Convert . ToInt16 ( char . Parse ( ZF實例 ) ):X4}）" +
                $"= " +
                $"{ZF另一個}（U+{Convert . ToInt16 ( char . Parse ( ZF另一個 ) ):X4}）：" +
                $"{ZF實例 . Equals ( ZF另一個 , bj )}" );
            }
        Console . WriteLine ( );
        }
    }

備註

Equals ( object )、Equals ( string ) 和 Equals ( string , string )

此方法執行序號（區分大小寫且不區分區域性）比較。

Equals ( string , StringComparison )

StringComparison 參數指示比較應使用當前區域性還是固定區域性、區分還是忽略所比較的兩個字符串的大小寫，或者使用單詞排序規則還是序號排序規則。

String . Format

根據指定的格式將對象的值轉換為字符串，並將它們插入到另一個字符串中。

重載

參數

返回值

異常

示例

此示例使用 Format ( String , Object , Object , Object ) 方法創建一個字符串，以説明兩個整數值進行布爾 And 運算的結果。請注意，格式字符串包含六個格式項，但該方法的參數列表中只有三個項，因為每個項都以兩種不同的方式進行了格式化。

string zfc格式化字符串 = "    {0,10} ({0,8:X8})\n" +
                           "And {1,10} ({1,8:X8})\n" +
                           "  = {2,10} ({2,8:X8})";
int Zhi1 = 54321;
int Zhi2 = 12345;
string zfcJieGuo = String . Format ( zfc格式化字符串 , Zhi1, Zhi2, Zhi1 & Zhi2 );
Console . WriteLine ( zfcJieGuo );

此示例使用 Format ( IFormatProvider , CompositeFormat , ReadOnlySpan < Object > ) 方法創建一個字符串，以自 ReadOnlySpan < object > 創建格式化字符串的結果。

CompositeFormat zfc模板 = CompositeFormat . Parse ( "{0} 的價格是 {1:C}" );

object [ ] zhs參數數組 = { "筆記本電腦" , 5999.99m };
ReadOnlySpan < object? > zhs參數 = zhs參數數組 . AsSpan ( );

IFormatProvider zfc中文格式 = CultureInfo . GetCultureInfo ( "zh-CN" );
IFormatProvider zfc英文格式 = CultureInfo . GetCultureInfo ( "en-US" );

string zfc中文結果 = string . Format ( zfc中文格式 , zfc模板 , zhs參數 );
string zfc英文結果 = string . Format ( zfc英文格式 , zfc模板 , zhs參數 );

Console . WriteLine ( zfc中文結果 ); // 筆記本電腦 的價格是 ￥5,999.99
Console . WriteLine ( zfc英文結果 ); // 筆記本電腦 的價格是 $5,999.99

此示例使用 Format ( IFormatProvider , CompositeFormat , object [ ] ) 方法創建一個字符串，以自 object [ ] 創建格式化字符串的結果。

object [ ] dxs = [ "我的" , 123 , DateTime . Now ];
CompositeFormat zfc模板 = CompositeFormat . Parse ( "{0} 的價格是 {1:C}，日期：{2:D}" );
string zfcJieGuo = string . Format ( CultureInfo . InvariantCulture , zfc模板 , dxs );
Console . WriteLine ( zfcJieGuo );

此示例使用 Format ( IFormatProvider , String , ReadOnlySpan < Object > ) 方法創建一個字符串，以自 scoped ReadOnlySpan < object? > 為格式化對象。

// 1. 定義複合格式字符串
string formatString = "【{0,-10}】價格：{1:C} | 庫存：{2,5:N0} | 上架時間：{3:D}";

// 2. 創建不同的格式提供者（特定於區域性的格式信息）
IFormatProvider geshi中國 = CultureInfo . GetCultureInfo ( "zh-CN" );
IFormatProvider geshi英國 = CultureInfo . GetCultureInfo ( "en-US" );
IFormatProvider geshi日本 = CultureInfo . GetCultureInfo ( "ja-JP" );

// 3. 準備參數（使用數組，然後轉換為ReadOnlySpan）
object [ ] CP信息 = [
            "筆記本電腦",                    // {0} 商品名稱
            5999.99m,                         // {1} 價格（decimal 類型確保精度）
            1234,                                // {2} 庫存數量
            new DateTime( 2025 , 1 , 15 )        // {3} 上架時間
        ];

// 轉換為ReadOnlySpan<Object>
ReadOnlySpan < object? > canshus = new ( CP信息 );

// 4. 使用不同的格式提供者進行格式化
Console . WriteLine ( "=== 中文格式 ===" );
string zfc中國 = string . Format( geshi中國 , formatString , canshus );
Console . WriteLine ( zfc中國 );

Console . WriteLine ( "\n=== 英文格式 ===" );
string zfc英文 = string . Format(geshi英國, formatString, canshus);
Console . WriteLine ( zfc英文 );

Console . WriteLine ( "\n=== 日語格式 ===" );
string zfc日文 = string . Format ( geshi日本 , formatString , canshus );
Console . WriteLine ( zfc日文 );

// 5. 格式説明詳解
Console . WriteLine ( "\n=== 格式説明 ===" );
Console . WriteLine ( "- {0,-10}：商品名稱左對齊，佔10個字符" );
Console . WriteLine ( "- {1:C}：價格格式化為貨幣" );
Console . WriteLine ( "- {2,5:N0}：庫存右對齊，佔5個字符，千位分隔" );
Console . WriteLine ( "- {3:D}：日期格式化為長日期格式" );// 1. 定義複合格式字符串
string formatString = "【{0,-10}】價格：{1:C} | 庫存：{2,5:N0} | 上架時間：{3:D}";

// 2. 創建不同的格式提供者（特定於區域性的格式信息）
IFormatProvider geshi中國 = CultureInfo . GetCultureInfo ( "zh-CN" );
IFormatProvider geshi英國 = CultureInfo . GetCultureInfo ( "en-US" );
IFormatProvider geshi日本 = CultureInfo . GetCultureInfo ( "ja-JP" );

// 3. 準備參數（使用數組，然後轉換為ReadOnlySpan）
object [ ] CP信息 = [
            "筆記本電腦",                    // {0} 商品名稱
            5999.99m,                         // {1} 價格（decimal 類型確保精度）
            1234,                                // {2} 庫存數量
            new DateTime( 2025 , 1 , 15 )        // {3} 上架時間
        ];

// 轉換為ReadOnlySpan<Object>
ReadOnlySpan < object? > canshus = new ( CP信息 );

// 4. 使用不同的格式提供者進行格式化
Console . WriteLine ( "=== 中文格式 ===" );
string zfc中國 = string . Format( geshi中國 , formatString , canshus );
Console . WriteLine ( zfc中國 );

Console . WriteLine ( "\n=== 英文格式 ===" );
string zfc英文 = string . Format(geshi英國, formatString, canshus);
Console . WriteLine ( zfc英文 );

Console . WriteLine ( "\n=== 日語格式 ===" );
string zfc日文 = string . Format ( geshi日本 , formatString , canshus );
Console . WriteLine ( zfc日文 );

// 5. 格式説明詳解
Console . WriteLine ( "\n=== 格式説明 ===" );
Console . WriteLine ( "- {0,-10}：商品名稱左對齊，佔10個字符" );
Console . WriteLine ( "- {1:C}：價格格式化為貨幣" );
Console . WriteLine ( "- {2,5:N0}：庫存右對齊，佔5個字符，千位分隔" );
Console . WriteLine ( "- {3:D}：日期格式化為長日期格式" );

// 創建一個自定義的格式提供程序
IFormatProvider 格式提供程序 = CultureInfo . GetCultureInfo ( "zh-CN" );

// 創建一個複合格式字符串
CompositeFormat 格式字符串 = CompositeFormat . Parse ( "尊敬的{0}，您的賬户餘額為{1:C}" );

// 定義要格式化的參數
string 用户名 = "陛下";
decimal 賬户餘額 = 12345.67m;

// 使用 Format<TArg0,TArg1> 方法進行格式化
string 結果 = string.Format(
            格式提供程序,
            格式字符串,
            用户名,
            賬户餘額
        );

// 輸出結果
Console . WriteLine ( 結果 );
// 輸出：尊敬的陛下，您的賬户餘額為￥12,345.67

備註

重要提示：無需調用 String . Format 方法或使用複合格式字符串，如果您使用的語言支持，您可以使用插值字符串。插值字符串是包含插值表達式的字符串。每個插值表達式都會用表達式的值解析，並在字符串被賦值時包含在結果字符串中。

Format ( IFormatProvider? 格式提供者 , String 複合格式字符串 , Object? dx0 , Object? dx1 , Object? dx2 ) 方法使用複合格式化功能將三個（或兩個）表達式轉換為其字符串表示形式，並將這些表示形式嵌入到字符串中。在執行轉換時，該方法使用區域性敏感格式化或自定義格式化程序。此方法通過調用每個對象參數的 ToString ( IFormatProvider ) 方法（或者，如果對象對應的格式項包含格式字符串，則調用其 ToString ( String , IFormatProvider ) 方法），將其轉換為字符串表示形式。如果這些方法不存在，則調用該對象的無參數 ToString 方法。

但是，調用 String . Format 方法時，無需關注要調用的特定重載。相反，您可以使用提供區域性敏感格式或自定義格式的對象以及包含一個或多個格式項的複合格式字符串來調用該方法。為每個格式項分配一個數字索引，第一個索引從 0 開始。除初始字符串外，方法調用中應包含與索引值數量相同的附加參數。例如，格式項索引為 0 和 1 的字符串應包含 2 個參數；索引為 0 到 5 的字符串應包含 6 個參數。然後，語言編譯器會將您的方法調用解析為 String . Format 方法的特定重載。

String . GetEnumerator

獲取一個可循環訪問此字符串中各個 Char 的對象。
public CharEnumerator GetEnumerator ( );

返回值

示例

以下示例遍歷多個字符串中的字符，並顯示有關其各個字符的信息。它使用語言迭代結構，而不是調用 GetEnumerator 方法。

FF枚舉和顯示 ( "Test Case" );
FF枚舉和顯示 ( "This is a sentence." );
FF枚舉和顯示 ( "Has\ttwo\ttabs" );
FF枚舉和顯示 ( "Two\nnew\nlines" );

static void FF枚舉和顯示 ( string 語句 )
    {
    Console . WriteLine ( $"String {語句} 中的 字符：" );

    int zhsZF = 0;
    int zhsKongZhiZF = 0;
    int zhsZFzimushuzi = 0;
    int zhsZFbiaodian = 0;

    foreach ( var zf in 語句 )
        {
        Console . Write ( Char . IsControl ( zf ) ? $"{zf}" : $"0x{( short ) zf:X4}" );

        if ( Char . IsLetterOrDigit ( zf ) )
            zhsZFzimushuzi++;
        else if ( Char . IsControl ( zf ) )
            zhsKongZhiZF++;
        else if ( Char . IsPunctuation ( zf ) )
            zhsZFbiaodian++;
        zhsZF++;
        }

    Console . WriteLine ( $"\n   總字符數：        {zhsZF,3}" );
    Console . WriteLine ( $"   字母或數字字符：{zhsZFzimushuzi,3}" );
    Console . WriteLine ( $"   標點符號字符：{zhsZFbiaodian,3}" );
    Console . WriteLine ( $"   控制字符：{zhsKongZhiZF,3}\n" );
    }

備註

無需調用 GetEnumerator 方法來檢索 CharEnumerator 對象，然後使用該對象枚舉字符串，而是應該使用編程語言的迭代結構。例如，C# 中的 foreach、F# 中的 for…in 以及 Visual Basic 中的 For Each。

此方法使您能夠迭代字符串中的各個字符。例如，Visual Basic 的 For Each、F# 的 for…in 表達式以及 C# 的 foreach 語句會調用此方法，以返回一個 CharEnumerator 對象，該對象可提供對該字符串實例中字符的只讀訪問權限。

String . GetHashCode

重載

public override int GetHashCode ( );
public static int GetHashCode ( ReadOnlySpan < char > 值 );
public int GetHashCode ( StringComparison 比較選項 );
public static int GetHashCode ( ReadOnlySpan < char > 值 , StringComparison 比較選項 );

參數

返回值

示例

以下示例使用各種輸入字符串演示了 GetHashCode 方法。

string [ ] ZFCs = [ "a", "ab", "我喜歡豆包", "" ];
foreach ( StringComparison xuanxiang in Enum . GetValues<StringComparison> ( ) )
    {
    foreach ( string zfc in ZFCs )
        {
        FF顯示哈希碼 ( zfc , xuanxiang );
        FF顯示範圍哈希碼 ( zfc . AsSpan ( ) , xuanxiang );
        }
    }

static void FF顯示哈希碼 ( String 字符串 , StringComparison 選項 )
    {
    int zhs哈希碼 = 字符串 . GetHashCode ( 選項 );
    Console . WriteLine ( $"String \"{字符串}\"（{選項}）的哈希碼是：0x{zhs哈希碼:X8}，{zhs哈希碼}" );
    }

static void FF顯示範圍哈希碼 ( ReadOnlySpan<char> 只讀字符範圍 , StringComparison 選項 )
    {
    int zhs哈希碼 = string . GetHashCode ( 只讀字符範圍 , 選項 );
    Console . WriteLine ( $"ReadOnlySpan\"{只讀字符範圍}\"（{選項}）的哈希碼是：0x{zhs哈希碼:X8}，{zhs哈希碼}" );
    }

備註

GetHashCode 的行為取決於其實現，這種實現可能會在公共語言運行時的不同版本之間發生變化。出現這種情況的一個原因是為了提高 GetHashCode 的性能。

重要提示：如果兩個字符串對象相等，則 GetHashCode 方法會返回相同的值。但是，每個唯一的字符串值並非都有唯一的哈希碼值。不同的字符串可能會返回相同的哈希碼。

重要提示：哈希碼本身並不能保證穩定性。對於相同的字符串，其哈希碼在不同的 .NET 實現之間、不同的 .NET 版本之間，以及同一 .NET 版本的不同 .NET 平台（如 32 位和 64 位）之間可能會有所不同。在某些情況下，甚至在不同的應用程序域之間也可能存在差異。這意味着同一程序的兩次連續運行可能會返回不同的哈希碼。

重要提示：因此，哈希碼絕不應在創建它們的應用程序域之外使用，絕不應作為集合中的關鍵字段使用，也絕不應被持久化。

重要提示：最後，如果你需要加密強度高的哈希，不要使用哈希碼來替代加密哈希函數返回的值。對於加密哈希，請使用從 System . Security . Cryptography . HashAlgorithm 或 System . Security . Cryptography . KeyedHashAlgorithm 類派生的類。

在 .NET Framework 桌面應用中，您可以使用 < UseRandomizedStringHashAlgorithm > 元素在每個應用程序域的基礎上生成唯一的哈希代碼。這可以減少衝突數量，並提高使用哈希表的插入和查找的整體性能。下面的示例展示瞭如何使用 < UseRandomizedStringHashAlgorithm > 元素。它定義了一個 LEI顯示字符串 類，該類包含一個私有字符串常量 zfc，其值為 “This is a string.”。它還包含一個 FF顯示字符串哈希碼 方法，該方法會顯示字符串值及其哈希代碼，以及執行該方法的應用程序域的名稱。

LEI顯示字符串 CS = new ( );
CS . FF顯示字符串哈希碼 ( );

LEI顯示字符串 CS2 = Activator . CreateInstance<LEI顯示字符串> ( );
CS2 . FF顯示字符串哈希碼 ( );


public class LEI顯示字符串 : MarshalByRefObject
    {
    private string zfc = "This is a string.";

    public override bool Equals ( object? obj )
        {
        string? zfc2 = obj as string;
        if ( zfc2 == null ) { return false; } else { return zfc == zfc2; }
        }

    public bool Equals ( string 字符串 )
        {
        return zfc == 字符串;
        }

    public override int GetHashCode ( )
        {
        return zfc . GetHashCode ( );
        }

    public override string ToString ( ) { return zfc; }

    public void FF顯示字符串哈希碼 ( )
        {
        Console . WriteLine ( $"String ‘{zfc}’ 在域 ‘{AppDomain . CurrentDomain . FriendlyName}’ 中：{zfc . GetHashCode ( ):X8}" );
        }
    }

備註：上例中的 LEI顯示字符串 沒有問題，但我是在 .NET 中寫的，故無法實現 GetHashCode 返回值的不同，請查看原版 MSDN 並創建 .NET Framework 應用程序查看結果。
String ‘This is a string.’ in domain ‘PerDomain.exe’: 941BCEAC
String ‘This is a string.’ in domain ‘NewDomain’: 941BCEAC
然而，如果你將以下配置文件添加到示例目錄中，然後運行該示例，那麼同一字符串的哈希碼將因應用程序域的不同而有所差異。

<?xml version ="1.0"?>
<configuration>
   <runtime>
      <UseRandomizedStringHashAlgorithm enabled="1" />
   </runtime>
</configuration>

String ‘This is a string.’ in domain ‘PerDomain.exe’: 5435776D
String ‘This is a string.’ in domain ‘NewDomain’: 75CC8236
重要提示：哈希碼用於高效地從哈希表中插入和檢索帶鍵對象。但是，哈希碼並不能唯一標識字符串。相同的字符串具有相等的哈希碼，但公共語言運行時也可能為不同的字符串分配相同的哈希碼。此外，哈希碼可能因 .NET 版本、同一版本內的平台以及應用程序域而有所不同。因此，不應序列化或持久化哈希碼值，也不應將它們用作哈希表或字典中的鍵。

調用者注意事項

GetHashCode ( ) 返回的值取決於平台。它在 .NET Framework 的 32 位和 64 位版本上有所不同。在 .NET Framework 和 .NET Core 的不同版本之間，該值也可能存在差異。

String . GetPinnableReference

返回對字符串索引為零處元素的引用。

此方法旨在支持 .NET 編譯器，不建議用户代碼調用。
public ref readonly char GetPinnableReference ( );

返回值

異常

備註

GetPinnableReference 方法返回一個可用於在內存中固定 String 的字符。這是在 fixed 語句中使用 String 所必需的。

String . GetTypeCode

返回 String 類的 TypeCode。
public TypeCode GetTypeCode ( );

返回值

實現

GetTypeCode ( )

示例

String zfc = "abc";
TypeCode leixingdaima = zfc . GetTypeCode ( );
Console . WriteLine ( $"{zfc} 的 TypeCode 是 {leixingdaima:D}，這表示 {leixingdaima:F}。" );

String . IndexOf 和 String . LastIndexOf

報告此實例中指定 Unicode 字符或字符串首次出現的從零開始的索引。如果在此實例中未找到該字符或字符串，此方法返回 -1。

重載

參數

返回值

異常

示例

以下示例展示瞭如何使用 IndexOf 方法在 String 中搜索 Char。

// 創建一個包含 5 個希臘字母 Alpha 的 Unicode 字符串
String zfc希臘阿爾法 = new ( '\u0391' , 5 );

// 創建一個包含 3 個希臘字母 Omega 的 Unicode 字符串
String zfc希臘奧美噶 = "\u03A9\u03A9\u03A9";

String zfc希臘字母們 = String . Concat ( zfc希臘奧美噶 , zfc希臘阿爾法 , zfc希臘奧美噶 . Clone ( ) );

// 完整字符串內容為
Console . WriteLine ( $"String：{zfc希臘字母們}" );

// 第一個 Alpha 的索引
int zhsAlpha1 = zfc希臘字母們 . IndexOf ( '\u0391' );
// 第一個 Omega 的索引
int zhsOmega1 = zfc希臘字母們 . IndexOf ( '\u03A9' );

// 最後一個 Alpha 的索引
int zhsAlphaH = zfc希臘字母們 . LastIndexOf ( '\u0391' );
// 最後一個 Omega 的索引
int zhsOmegaH = zfc希臘字母們 . LastIndexOf ( '\u03A9' );

Console . WriteLine ( $"首次出現希臘字母 Alpha 的位置：索引 {zhsAlpha1}" );
Console . WriteLine ( $"首次出現希臘字母 Omega 的位置：索引 {zhsOmega1}" );
Console . WriteLine ( $"最後出現希臘字母 Alpha 的位置：索引 {zhsAlphaH}" );
Console . WriteLine ( $"最後出現希臘字母 Omega 的位置：索引 {zhsOmegaH}" );

以下示例在目標字符串中搜索指定字符串的所有出現位置。

string zfcYuan = "這是我今天的棉襖，你覺着棉襖漂亮嗎？";

Console . WriteLine ( $"欲搜索的字符串是：\n→ {zfcYuan}\n" );

string? zfcMuBiao;
int zhsZD, zhsZD次數 = 0;

do
    {
    Console . Write ( "請輸入要在上述字符串中查找的搜索值（按回車鍵退出）==>" );

    zfcMuBiao = Console . ReadLine ( );

    if ( string . IsNullOrEmpty ( zfcMuBiao ) )
        {
        return;
        }

    // 使用 ! 操作符告訴編譯器 zfcMuBiao 不為 null
    for ( int i = 0 ; i < zfcYuan . Length ; i++ )
        {
        zhsZD = zfcYuan . IndexOf ( zfcMuBiao! , i );  // 添加 ! 操作符

        if ( zhsZD >= 0 )
            {
            zhsZD次數++;
            i = zhsZD;
            }
        else
            {
            break;
            }
        }

    Console . WriteLine ( $"\n搜索參數 ‘{zfcMuBiao}’ 找到了 {zhsZD次數} 次。\n" );

    zhsZD次數 = 0;
    } while ( true );

以下示例在 “animal” 中搜索 “n”。由於字符串索引從 0 而不是 1 開始，IndexOf ( String ) 方法表明 “n” 位於位置 1。

String zfc = "animal";
String zfc查找 = "n";
int zhs索引 = zfc . IndexOf ( zfc查找 );
Console . WriteLine ( $"在 {zfc} 中找到 ‘{zfc查找}’，位置在  {zhs索引}" );

以下示例使用 IndexOf 方法確定動物名稱在句子中的起始位置。然後，它使用這個位置將描述該動物的形容詞插入到句子中。

string zfc狐狸 = "狐狸";
string zfc狗 = "狗";

string zfc目標 = String . Format ( $"{zfc狐狸} 跳過了 {zfc狗}。" );

Console . WriteLine ( $"原始字符串是：\n{zfc目標}\n" );

Console . Write ( $"輸入一個形容詞（或一組形容詞）來描述 {zfc狐狸}：==> " );
string? zfc狐狸描述 = Console . ReadLine ( );

Console . Write ( $"輸入一個形容詞（或一組形容詞）來描述 {zfc狗}：==> " );
string? zfc狗描述 = Console . ReadLine ( );

if ( zfc狐狸描述 != null && zfc狗描述 != null )
    {
    zfc狐狸描述 = zfc狐狸描述 . Trim ( ) + " ";
    zfc狗描述 = zfc狗描述 . Trim ( ) + " ";
    zfc目標 = zfc目標 . Insert ( zfc目標 . IndexOf ( zfc狐狸 ) , zfc狐狸描述 );
    zfc目標 = zfc目標 . Insert ( zfc目標 . IndexOf ( zfc狗 ) , zfc狗描述 );
    }

Console . WriteLine ( $"\n最終語句：\n{zfc目標}" );

以下示例演示了 LastIndexOf 方法找到 實例中 所有的 “t” 字符：

string biaoti1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-";
string biaoti2 = "0123456789012345678901234567890123456789012345678901234567890123456";
string zfc = "Now is the time for all good men to come to the aid of their party.";
int zhsQiShi = zfc . Length -1;
int at;

Console . WriteLine ( $"從位置 {zhsQiShi} 到 0 之間的所有 “t” 字符的出現情況。" );
Console . WriteLine ( $"{biaoti1}\n{biaoti2}\n{zfc}\n" );
Console . Write ( "字母 “t” 出現的位置為：" );

at = 0;
while ( ( zhsQiShi > -1 ) && ( at > -1 ) )
    {
    at = zfc . LastIndexOf ( 't' , zhsQiShi );
    if ( at > -1 )
        {
        Console . Write ( $"{at} " );
        zhsQiShi = at - 1;
        }
    }
Console . WriteLine ( );

以下示例展示了 LastIndexOf 方法的三個重載，這些重載使用 StringComparison 枚舉的不同值來查找一個字符串在另一個字符串中的最後一次出現。

string zfc簡介 = "使用不同的字符串比較方式來查找某個字符的最後出現位置。";
string zfc格式 = "比較：{0,-28}，位置：{1,3}";

// 定義一個要搜索的字符串
// U+00C5 = 拉丁大寫字母 A 上加圓環
string zfc大寫圓環A = "\u00c5";

// 定義一個要搜索的字符串
// 將拉丁小寫字母 “A” 與組合上標圓環（U+0061 , U+030a）組合在一起所得到的結果，在語言層面上等同於拉丁小寫字母 “帶有上標圓環的 A”（U+00e5）
string cat = "A Cheshire c" + "\u0061\u030a" + "t";
int zhsWeiZhi;
StringComparison [ ] ZFC比較選項s = [
        StringComparison . CurrentCulture,
        StringComparison . CurrentCultureIgnoreCase,
        StringComparison . InvariantCulture,
        StringComparison . InvariantCultureIgnoreCase,
        StringComparison . Ordinal,
        StringComparison . OrdinalIgnoreCase ];

// 清屏並顯示簡介
Console . Clear ( );
Console . OutputEncoding = Encoding . UTF8;
Console . WriteLine ( zfc簡介 );

// 顯示當前的環境文化，因為文化會對結果產生影響。例如，可以將此代碼示例與 “sv-SE”（瑞典 - 瑞典）文化進行搭配使用

Thread . CurrentThread . CurrentCulture = new CultureInfo ( "en-US" );
Console . WriteLine ( $"當前區域性文化為：“{Thread . CurrentThread . CurrentCulture . Name}” - {Thread . CurrentThread . CurrentCulture . DisplayName}。" );

// 顯示要搜索的字符以及要進行搜索的字符串
Console . WriteLine ( $"在字符串 “{cat}” 中搜索字符串 “{zfc大寫圓環A}”" );
Console . WriteLine ( );

// 請注意，在以下的每項搜索中，我們會在包含 “帶有上方圓環的拉丁大寫字母 A” 這一詞的字符串中查找 “帶有上方圓環的拉丁小寫字母 A”。如果未找到該字符串，則結果值為 -1
// 可以使用不同的字符串比較值進行搜索。請指定起始索引和計數

Console . WriteLine ( "第一項：指定起始索引 和 字符數。" );
foreach ( StringComparison xuanxiang in ZFC比較選項s )
    {
    zhsWeiZhi = cat . LastIndexOf ( zfc大寫圓環A , cat . Length - 1 , cat . Length , xuanxiang );
    Console . WriteLine ( zfc格式 , xuanxiang , zhsWeiZhi );
    }

// 根據不同的字符串比較方式進行搜索。請明確説明開始索引
Console . WriteLine ( "\n第二項：指定起始索引。" );
foreach ( StringComparison xuanxiang in ZFC比較選項s )
    {
    zhsWeiZhi = cat . LastIndexOf ( zfc大寫圓環A , cat . Length - 1 , xuanxiang );
    Console . WriteLine ( zfc格式 , xuanxiang , zhsWeiZhi );
    }

// 使用不同的字符串比較值進行搜索
Console . WriteLine ( "\n第三項：既未指定起始索引，也未指定計數。" );
foreach ( StringComparison xuanxiang in ZFC比較選項s )
    {
    zhsWeiZhi = cat . LastIndexOf ( zfc大寫圓環A , xuanxiang );
    Console . WriteLine ( zfc格式 , xuanxiang , zhsWeiZhi );
    }

字符集包含可忽略字符，這些字符在進行語言或文化敏感的比較時不會被考慮。在文化敏感的搜索中，如果 實例 包含可忽略字符，結果等同於移除該字符後進行搜索。如果 實例 僅由一個或多個可忽略字符組成，IndexOf ( String ) 方法總是返回 0（零），表示在當前實例的開頭找到了匹配項。在下面的示例中，IndexOf ( String ) 方法用於在兩個字符串中查找三個子字符串（軟連字符（U+00AD）、軟連字符後接 “n” 以及軟連字符後接 “m”）。只有其中一個字符串包含軟連字符。如果在 .NET Framework 4 或更高版本上運行此示例，在每種情況下，由於軟連字符是可忽略字符，結果與 實例 中未包含軟連字符時的結果相同。當僅搜索軟連字符時，該方法返回 0（零），表示在字符串的開頭找到了匹配項。

string zfc1 = "ani\u00ADmal";
string zfc2 = "animal";

// 找到 軟連字符 的索引位置（字符方式）
Console . WriteLine ( zfc1 . IndexOf ( '\u00AD' ) );
Console . WriteLine ( zfc2 . IndexOf ( '\u00AD' ) );

// 找到 軟連字符 的索引位置（字符串方式）
Console . WriteLine ( zfc1 . IndexOf ( "\u00AD" ) );
Console . WriteLine ( zfc2 . IndexOf ( "\u00AD" ) );

// 找出緊跟在 “n” 後面的 軟連字符 的索引位置
Console . WriteLine ( zfc1 . IndexOf ( "\u00ADn" ) );
Console . WriteLine ( zfc2 . IndexOf ( "\u00ADn" ) );

// 找出緊跟在 “m” 前面的 軟連字符 的索引位置
Console . WriteLine ( zfc1 . IndexOf ( "\u00ADm" ) );
Console . WriteLine ( zfc2 . IndexOf ( "\u00ADm" ) );

註解

索引標號從 0 開始。索引 參數的取值範圍為 0 ～ 實例 . Length。

IndexOf 方法搜索從 0 或 索引 參數開始，一直持續到 索引 + 字符數 - 1 或 實例 末尾（未指定 字符數 參數）。LastIndexOf 方法搜索從 0 或 索引 參數開始，一直持續到 索引 + 字符數 - 1 或 實例 起始（未指定 字符數 參數）。位於 索引 + 字符數 處的字符不包含在搜索範圍內。當搜索到 zf 或 zfc 時，搜索即終止。

若未指定 比較選項，此方法執行序數（不區分區域性且區分大小寫）搜索，實例中某個（組）字符僅當其 Unicode 標量值相同時才被視為與 zf 或 zfc 等效。若要執行區分區域性的搜索，請使用 CompareInfo . IndexOf 和 CompareInfo . LastIndexOf 方法，在此方法中，代表預合成字符（如連字 “Æ” （U+00C6））的 Unicode 標量值可能被視為與該字符的組成部分按正確順序出現的任何情況等效，例如 “AE” （U+0041、U+0045），具體取決於區域性。

比較選項 參數指定使用當前區域性或固定區域性、區分大小寫或不區分大小寫的搜索以及單詞或序號比較規則來搜索 zf 或 zfc 參數。

調用者指南

字符集包含可忽略字符，這些字符在進行語言或文化相關的比較時不會被考慮。在文化相關的搜索中（即如果 比較選項 不是 Ordinal 或 OrdinalIgnoreCase），如果 zfc 包含可忽略字符，結果等同於移除該字符後進行搜索的結果。如果 zfc 僅由一個或多個可忽略字符組成，IndexOf ( String , Int32 , Int32 , StringComparison ) 方法將始終返回 0 或 索引，即搜索開始的字符位置。

#region 【變量定義區】
// 搜索目標：軟連字符 + 'm' 組合
string zfc搜索字符串 = "\u00ADm";

// 測試字符串定義 - 全部zfc開頭！
string zfc1 = "ani\u00ADmal";     // 包含軟連字符 (ani-mal)
string zfc2 = "animal";           // 不包含軟連字符 (animal)
#endregion

#region 【核心知識點】
/*
 * 軟連字符（\u00AD）特性：
 * 1. 屬於"可忽略字符"，在文化敏感比較中會被自動忽略
 * 2. 僅在需要換行時才顯示為連字符，正常顯示時不可見
 * 3. 這就是為什麼 IndexOf 會有"看似奇怪"的行為
 */
#endregion
Console . OutputEncoding = Encoding . UTF8;

// ==============================================
// 【文化敏感比較】- CurrentCulture
// 特點：軟連字符會被忽略，相當於搜索 "m"
// ==============================================
Console . WriteLine ( "\n【模式一：文化敏感比較】" );
Console . WriteLine ( "→ 軟連字符被視為可忽略字符，自動忽略" );
Console . WriteLine ( $"zfc1 . IndexOf ( zfc搜索字符串 , 2 , 4 ) = {zfc1 . IndexOf ( zfc搜索字符串 , 2 , 4 , StringComparison . CurrentCulture )}" );
Console . WriteLine ( $"zfc2 . IndexOf ( zfc搜索字符串 , 2 , 4 ) = {zfc2 . IndexOf ( zfc搜索字符串 , 2 , 4 , StringComparison . CurrentCulture )}" );

// ==============================================
// 【序數比較】- Ordinal  
// 特點：嚴格按照 Unicode 碼點比較，精確匹配
// ==============================================
Console . WriteLine ( "\n【模式二：序數比較】" );
Console . WriteLine ( "→ 嚴格按 Unicode 碼點比較，不忽略任何字符" );
Console . WriteLine ( $"zfc1 . IndexOf ( zfc搜索字符串 , 2 , 4 ) = {zfc1 . IndexOf ( zfc搜索字符串 , 2 , 4 , StringComparison . Ordinal )}" );
Console . WriteLine ( $"zfc2 . IndexOf ( zfc搜索字符串 , 2 , 4 ) = {zfc2 . IndexOf ( zfc搜索字符串 , 2 , 4 , StringComparison . Ordinal )}" );

Console . WriteLine ( "\n==================================" );
Console . WriteLine ( "【結果解讀】" );
Console . WriteLine ( "==================================" );
Console . WriteLine ( "• 注意：起始索引從 2 開始（跳過 an 兩個字符）" );
Console . WriteLine ( "• 文化敏感比較：zfc1 返回 4（實際是找到 ‘m’ 的位置，忽略軟連字符）；zfc2 返回 3（即找到了 ‘m’ 的位置）" );
Console . WriteLine ( "• 序數比較：zfc1 返回 3（找到 軟連字符 + m），zfc2 返回 -1（未找到）" );
Console . WriteLine ( "• 結論：處理特殊字符時，務必明確指定比較方式！" );

String . IndexOfAny 和 LastIndexOfAny

IndexOfAny 報告 實例 中指定 Unicode 字符數組中任何字符的自左向右首次出現位置的索引。LastIndexOfAny 報告 實例 中指定 Unicode 字符數組中任何字符的自右向左首次出現位置的索引。如果在該實例中未找到數組中的字符，兩個方法均返回 -1。

重載

參數

返回值

異常

示例

char [ ] ZFs = [ 'a' , 'e' , 'i' , 'o' , 'u' , 'y' , 'A' , 'E' , 'I' , 'O' , 'U' , 'Y' ];
string zfc = "The long and winding road...";
Console . WriteLine ( $"{zfc} 中第一個元音字母位於 {zfc . IndexOfAny ( ZFs )}" );

以下示例將在一個字符串的子串中查找字符串 “is” 中任意字符出現的索引。

string zfcbiaoti1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-";
string zfcbiaoti2 = "0123456789012345678901234567890123456789012345678901234567890123456";
string zfc = "Now is the time for all good men to come to the aid of their party.";
int zhsqishi = zfc . Length / 2;
int zhsWeiYu;
string zfcMuBiao = "is";
char [ ] ZFsMuBiao = zfcMuBiao . ToCharArray ( );

Console . WriteLine ( );
Console . WriteLine ( $"從位置 {zhsqishi} 到 {zfc . Length - 1} 的 {zfcMuBiao} 出現位置：" );
Console . WriteLine ( $"""
    {Environment . NewLine}{zfcbiaoti1}{Environment . NewLine}
    {zfcbiaoti2}{Environment . NewLine}{zfc}{Environment . NewLine}
    """ );
Console . Write ( $"在 “{zfcMuBiao}” 中，某個角色出現在位置（從一半開始搜的）：" );

zhsWeiYu = zfc . IndexOfAny ( ZFsMuBiao , zhsqishi );
if ( zhsWeiYu > -1 )
    Console . Write ( zhsWeiYu );
else
    Console . Write ( "（未找到）" );
Console . WriteLine ( );

以下示例將查找字符串 “aid” 中的任何字符在另一個字符串的子串中出現的索引。

string zfcbiaoti1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-";
string zfcbiaoti2 = "0123456789012345678901234567890123456789012345678901234567890123456";
string zfc = "Now is the time for all good men to come to the aid of their party.";
int zhsqishi = zfc . Length / 3;
int zhs字符數 = zfc . Length / 4;
int zhsWeiYu;
string zfcMuBiao = "aid";
char [ ] ZFsMuBiao = zfcMuBiao . ToCharArray ( );

Console . WriteLine ( );
Console . WriteLine ( $"從位置 {zhsqishi} 數 {zhs字符數} 個字符中 {zfcMuBiao} 出現位置：" );
Console . WriteLine ( $"""
    {Environment . NewLine}{zfcbiaoti1}{Environment . NewLine}
    {zfcbiaoti2}{Environment . NewLine}{zfc}{Environment . NewLine}
    """ );
Console . Write ( $"在 “{zfcMuBiao}” 中，某個角色出現在位置（從 1/3（{zhsqishi}）處開始搜 {zhs字符數} 個字符）：" );

zhsWeiYu = zfc . IndexOfAny ( ZFsMuBiao , zhsqishi , zhs字符數 );
if ( zhsWeiYu > -1 )
    Console . Write ( zhsWeiYu );
else
    Console . Write ( "（未找到）" );
Console . WriteLine ( );

備註

索引號從 0 開始。若指定 索引，取值範圍 [ 0 , 實例 . Length - 1 ]。若指定 字符數，索引 + 字符數 不能大於 實例 . Length - 1，此時搜索自 索引 起始，自 索引 + 字符數 - 1 處結束。

對 ZFs 的搜索區分大小寫。如果 ZFs 是一個空數組（不是 null，而是沒有元素），該方法會返回 -1。

此方法執行序號（不區分區域性）搜索，其中一個字符被視為與另一個字符等效的唯一條件是它們的 Unicode 標量值相同。要執行區分區域性的搜索，請使用 CompareInfo . IndexOf 方法，在該方法中，代表預組合字符的 Unicode 標量值（如連字 “Æ”（U+00C6））可能會被視為與正確順序的字符組件的任何出現形式等效（如 “AE”（U+0041、U+0045）），具體取決於區域性。

String . Insert

返回一個新字符串，其中在該實例的指定索引位置插入了指定的字符串。
public string Insert ( int 起始索引 , string 值 );

參數

返回值

異常

示例

以下示例演示了 String . Insert 以及可能拋出的異常：

string [ ] zfsYanSes = [ "紅" , "綠" , "藍" , "黃" , "白" , "黑" ];
string zfc女人 = "那個女人穿了件衣服。";

foreach ( var ys in zfsYanSes )
    {
    string zfc = zfc女人 . Insert ( 7 , ys );
    Console . WriteLine ( zfc );
    }

string? zfcNull = null;
string zfcCha = "123";
try
    {
    string zfc = zfcCha . Insert ( 0 , zfcNull );
    }
catch ( Exception yc )
{ Console . WriteLine ( yc . Message ); }

string zfc狐狸 = "狐狸";
string zfc狗 = "狗";

string zfc目標 = String . Format ( $"{zfc狐狸} 跳過了 {zfc狗}。" );

Console . WriteLine ( $"原始字符串是：\n{zfc目標}\n" );

Console . Write ( $"輸入一個形容詞（或一組形容詞）來描述 {zfc狐狸}：==> " );
string? zfc狐狸描述 = Console . ReadLine ( );

Console . Write ( $"輸入一個形容詞（或一組形容詞）來描述 {zfc狗}：==> " );
string? zfc狗描述 = Console . ReadLine ( );

if ( zfc狐狸描述 != null ) zfc狐狸描述 = zfc狐狸描述 . Trim ( ) + " "; else zfc狐狸描述 = "隱身的 ";
if ( zfc狗描述 != null ) zfc狗描述 = zfc狗描述 . Trim ( ) + " "; else zfc狗描述 = "隱身的 ";

zfc目標 = zfc目標 . Insert ( zfc目標 . IndexOf ( zfc狐狸 ) , zfc狐狸描述 );
zfc目標 = zfc目標 . Insert ( zfc目標 . IndexOf ( zfc狗 ) , zfc狗描述 );

Console . WriteLine ( $"\n最後的字符串：\n{zfc目標}" );

備註

如果 起始索引 等於 實例 的長度，則會將 值 追加到 實例 的末尾。

既不能向 null 字符串中 Insert 任何字符串，也不能向任意非 null 字符串中 Insert null 字符串。

注意：此方法不會修改當前 實例 的值。相反，它會返回一個新字符串，其中 值 被插入到當前 實例 中。

例如：
zfcabc = "abc"
zfcABC = zfcabc . Insert ( 2 , "XYZ" );
此時 zfcABC 的值是 "abXYZc"；但 zfcabc 的值依然是 "abc"。

String . Intern 和 String . IsInterned

Intern 引用 .NET 字符串池中的字符串或將字符串引用添加到字符串駐留池中；IsInterned 檢查字符串是否存在於 . NET 字符串駐留池中。

public static string Intern ( string zfc );
public static string? IsInterned ( string zfcIs );

參數

返回值

異常

示例

以下示例使用三個值相等的字符串來判斷新創建的字符串和駐留字符串是否相等。

string zfc1 = "MyTest";
string zfc2 = new StringBuilder ( ) . Append ( "My" ) . Append ( "Test" ) . ToString ( );
string zfc3 = String . Intern ( zfc2 );
Console . WriteLine ( $"zfc1 == {zfc1}" );
Console . WriteLine ( $"zfc2 == {zfc2}" );
Console . WriteLine ( $"zfc3 == {zfc3}" );
Console . WriteLine ( $"zfc2 引用的是同一個 zfc1？：{( Object ) zfc2 == ( Object ) zfc1}" );
Console . WriteLine ( $"zfc3 引用的是同一個 zfc1？：{( Object ) zfc3 == ( Object ) zfc1}" );

以下示例表明，編譯器會自動對字符串字面量進行暫存。

// 在 .NET Framework 2.0 中，以下屬性聲明使您能夠在使用 NGEN.exe 將程序集編譯為原生圖像緩存時避免使用引用緩存機制
[ assembly: CompilationRelaxations ( CompilationRelaxations . NoStringInterning ) ]
class Program
    {
    public static void Main ( )
        {
        // 字符串 zfc1 在編譯時就已知，並且會自動被加入字符串池
        String zfc1 = "abcd";

        // 通過構造方法創建的字符串 zfc2，不會被顯式或自動地加入字符串池
        String zfc2 = new StringBuilder ( ) . Append ( "wx" ) . Append ( "yz" ) . ToString ( );
        Console . WriteLine ( );
        FF測試 ( 1 , zfc1 );
        FF測試 ( 2 , zfc2 );
        }

    public static void FF測試 ( int 次序 , String 字符串 )
        {
        Console . Write ( $"{次序}）本字符串，‘" );
        String? zfc暫存 = String . IsInterned ( 字符串 );
        if ( zfc暫存 == null )
            Console . WriteLine ( $"{字符串}’，沒有被暫存。" );
        else
            Console . WriteLine ( $"{zfc暫存}’，被暫存了。" );
        }
    }

備註

公共語言運行時通過維護一個名為 “字符串駐留池” 的表來節省字符串存儲，該表包含程序中以編程方式聲明或創建的每個唯一文本字符串的單個引用。因此，具有特定值的文本字符串實例在系統中僅存在一次。例如，如果將相同的文本字符串分配給多個變量，運行時會從駐留池中檢索該文本字符串的相同引用，並將其分配給每個變量。

Intern 方法使用字符串駐留池來搜索與參數 zfc 值相等的字符串。如果存在這樣的字符串，則返回其在駐留池中的引用。如果該字符串不存在，則會將 zfc 的引用添加到駐留池，然後返回該引用（相比之下，如果請求的字符串在駐留池中不存在，IsInterned ( String ) 方法會返回 null 引用）。

在第一個示例中，值為 “MyTest” 的字符串 zfc1 由於是程序中的文本，因此已被暫存。StringBuilder 類生成一個新的字符串對象，其值與 zfc1 相同。該字符串的引用被分配給 zfc2。Intern 方法會搜索與 zfc2 值相同的字符串。由於存在這樣的字符串，該方法返回分配給 zfc1 的相同引用。然後，該引用被分配給 zfc3。引用 zfc1 和 zfc2 的比較結果為不相等，因為它們指向不同的對象；引用 zfc1 和 zfc3 的比較結果為相等，因為它們指向同一個字符串。

性能考量

如果您試圖減少應用程序分配的總內存量，請記住，字符串駐留存在兩個不良副作用。首先，為駐留的 String 對象分配的內存可能要到公共語言運行時（CLR）終止時才會釋放。原因是，即使您的應用程序甚至應用程序域終止後，CLR 對駐留的 String 對象的引用也可能仍然存在。其次，要駐留字符串，您必須先創建該字符串。String 對象使用的內存仍必須分配，儘管該內存最終會被垃圾回收。

CompilationRelaxations . NoStringInterning 枚舉成員將程序集標記為不需要字符串字面量暫存。你可以使用 CompilationRelaxationsAttribute 特性將 NoStringInterning 應用於程序集。此外，當你使用 Ngen.exe（原生映像生成器）在運行時之前編譯程序集時，字符串不會跨模塊暫存。

String . IsNormalized 和 String . Normalize

IsNormalized 指示此字符串是否採用特定的 Unicode 規範化形式。Normalize 返回一個新字符串，其二進制表示採用特定的 Unicode 規範化形式。

重載

public bool IsNormalized ( );
public bool IsNormalized ( System . Text . NormalizationForm 規範化形式 );
public string Normalize ( );
public string Normalize ( System . Text . NormalizationForm 規範化形式 );

參數

返回值

異常

示例

以下示例判斷一個字符串是否成功規範化為各種規範化形式。

using System . Text;

Console . OutputEncoding = UTF8Encoding . UTF8;
// 字符 zf；複合字符（包含撇號和塞丁格線）；字符 3/4
string ZFCs = new ( [ '\u0063' , '\u0301' , '\u0327' , '\u00BE' ] );
string? zfc1 = null;
string zfc分隔符 = new ( '-' , 80 );
zfc分隔符 = String . Concat ( Environment . NewLine , zfc分隔符 , Environment . NewLine );

FF顯示字符串 ( "原始字符串" , ZFCs );
Console . WriteLine ( );
Console . WriteLine ( "U+0063 = 拉丁小寫字母 C" );
Console . WriteLine ( "U+0301 = 結合急性重音" );
Console . WriteLine ( "U+0327 = 結合懸垂符" );
Console . WriteLine ( "U+00BE = 不精確分數：四分之三" );
Console . WriteLine ( zfc分隔符 );

Console . WriteLine ( $"A1）ZFCs 是否已標準化為默認形式（形式 C）（ZFCs . IsNormalized ( )）？：{ZFCs . IsNormalized ( )}" );
Console . WriteLine ( $"A2）ZFCs 是否已標準化為默認形式（形式 C）（ZFCs . IsNormalized ( NormalizationForm . FormC )）？：{ZFCs . IsNormalized ( NormalizationForm . FormC )}" );
Console . WriteLine ( $"A3）ZFCs 是否已標準化為默認形式（形式 KC）（ZFCs . IsNormalized ( NormalizationForm . FormKC )）？：{ZFCs . IsNormalized ( NormalizationForm . FormKC )}" );
Console . WriteLine ( $"A4）ZFCs 是否已標準化為默認形式（形式 D）（ZFCs . IsNormalized ( NormalizationForm . FormD )）？：{ZFCs . IsNormalized ( NormalizationForm . FormD )}" );
Console . WriteLine ( $"A5）ZFCs 是否已標準化為默認形式（形式 KD）（ZFCs . IsNormalized ( NormalizationForm . FormKD )）？：{ZFCs . IsNormalized ( NormalizationForm . FormKD )}" );

Console . WriteLine ( zfc分隔符 );

Console . WriteLine ( "將字符串 “zfc1” 設置為字符串 “ZFCs” 的所有規範化形式。" );
Console . WriteLine ( );
Console . WriteLine ( "U+1E09 = 帶懸垂鈎和鋭音符的拉丁小寫字母 C" );
Console . WriteLine ( "U+0033 = 數字 3" );
Console . WriteLine ( "U+2044 = 分數分隔符" );
Console . WriteLine ( "U+0034 = 數字 4" );
Console . WriteLine ( zfc分隔符 );

zfc1 = ZFCs . Normalize ( );
Console . Write ( "B1）zfc1 是否已標準化為默認形式（形式 C）？：" );
Console . WriteLine ( zfc1 . IsNormalized ( ) );
FF顯示字符串 ( "zfc1" , zfc1 );
Console . WriteLine ( );

zfc1 = ZFCs . Normalize ( NormalizationForm . FormC );
Console . Write ( "B2）zfc1 是否已標準化為形式 C？：" );
Console . WriteLine ( zfc1 . IsNormalized ( NormalizationForm . FormC ) );
FF顯示字符串 ( "zfc1" , zfc1 );
Console . WriteLine ( );

zfc1 = ZFCs . Normalize ( NormalizationForm . FormD );
Console . Write ( "B3）zfc1 是否已標準化為形式 D？：" );
Console . WriteLine ( zfc1 . IsNormalized ( NormalizationForm . FormD ) );
FF顯示字符串 ( "zfc1" , zfc1 );
Console . WriteLine ( );

zfc1 = ZFCs . Normalize ( NormalizationForm . FormKC );
Console . Write ( "B4）zfc1 是否已標準化為形式 KC？：" );
Console . WriteLine ( zfc1 . IsNormalized ( NormalizationForm . FormKC ) );
FF顯示字符串 ( "zfc1" , zfc1 );
Console . WriteLine ( );

zfc1 = ZFCs . Normalize ( NormalizationForm . FormKD );
Console . Write ( "B5）zfc1 是否已標準化為默認形式（形式 KD）？：" );
Console . WriteLine ( zfc1 . IsNormalized ( NormalizationForm . FormKD ) );
FF顯示字符串 ( "zfc1" , zfc1 );
Console . WriteLine ( );

static void FF顯示字符串 ( string 標題 , string 字符串 )
    {
    Console . Write ( $"{標題} 字符串中的字符 = " );
    foreach ( char zf in 字符串 )
        {
        Console . Write ( $"{zf} (U+{( int ) zf:X4})；" );
        }
    Console . WriteLine ( );
    }

註解

一些 Unicode 字符具有多個等效的二進制表示形式，這些表示形式由一組組合和/或複合 Unicode 字符組成。單個字符存在多種表示形式，這會使搜索、排序、匹配和其他操作變得複雜。例如，以下任何代碼點都可以表示字母 “ắ”：

• U+1EAF
• U+0103 U+0301
• U+0061 U+0306 U+0301

Unicode 標準定義了一種稱為規範化的過程，當給定一個字符的任何等效二進制表示時，該過程會返回一個二進制表示。規範化可以通過幾種稱為規範化形式的算法來執行，這些算法遵循不同的規則。.NET 目前支持規範化形式 C、D、KC 和 KD。當兩個 string 以相同的規範化形式表示時，可以使用序號比較來對它們進行比較。

要規範化並比較兩個字符串，請執行以下操作：

1. 從輸入源（如文件或用户輸入設備）獲取要比較的字符串。
2. 調用 Normalize ( ) 方法，將字符串規範化為規範化形式 C。
3. 要比較兩個字符串，請調用支持序號字符串比較的方法，例如 Compare ( String , String , StringComparison ) 方法，並提供 StringComparison . Ordinal 或 StringComparison . OrdinalIgnoreCase 作為 StringComparison 參數的值。要對標準化字符串數組進行排序，請將 比較選項 值 StringComparer . Ordinal 或 StringComparer . OrdinalIgnoreCase 傳遞給 Array . Sort 的相應重載。
4. 根據上一步指示的順序，在排序後的輸出中生成字符串。

調用者備註

IsNormalized 方法在字符串中遇到第一個非規範化字符時會立即返回 false。因此，如果字符串包含非規範化字符，且其後跟有無效的 Unicode 字符，那麼儘管 IsNormalized 返回 false，Normalize 方法仍會拋出 ArgumentException 異常。

String . IsNullOrEmpty 和 String . IsNullOrWhiteSpace

指示指定的字符串是否為 null 或空字符串 （""）；或者指定的字符串是否為 null、String . Empty 或僅由空格組成的字符串 。

public static bool IsNullOrEmpty ( string? 字符串 );
public static bool IsNullOrWhiteSpace ( string? 字符串 );

參數

| 參數 | 類型 | 註解 |
| 字符串 | string? | 欲測試的字符串 |

返回值

| 方法 | 返回值類型 | 註解 |
| IsNullOrEmpty | bool | 如果 字符串 參數是 null 或者 String . Empty，返回 true
否則返回 false |
| IsNullOrWhiteSpace | bool | 如果 字符串 參數是 null 或者 String . Empty 或僅由空白字符（Unicode 定義）組成，返回 true
否則返回 false |

示例

string? [ ] ZFCs = [ "abcd" , "" , "    " , null ];
Console . WriteLine ( "String . IsNullOrEmpty 方法：" );
foreach ( string? zfc in ZFCs )
    {
    Console . WriteLine ( $"字符串 {( zfc == null ? "空" : $"{zfc}（{zfc . Length}）" )} 是：\n    {( string . IsNullOrEmpty ( zfc) ? "是 null 或者 Empty！" : "不是 null 或者 Empty！" )}" );
    }

Console . WriteLine ( "String . IsNullOrWhiteSpace 方法：" );
foreach ( string? zfc in ZFCs )
    {
    Console . WriteLine ( $"字符串 {( zfc == null ? "空" : $"{zfc}（{zfc . Length}）" )} 是：\n    {( string . IsNullOrWhiteSpace ( zfc ) ? "是 null 或者 Empty 或者 全是空格！" : "不是 null 或者 Empty 或者 全是空格！" )}" );
    }

註解

IsNullOrWhiteSpace 是一個便捷方法，它與以下代碼類似，但性能更優：
return String.IsNullOrEmpty(value) || value.Trim().Length == 0;
空白字符由 Unicode 標準定義。IsNullOrWhiteSpace 方法將任何傳遞給 Char . IsWhiteSpace 方法時返回 true 值的字符都視為空白字符。

String . Join

使用指定的分隔符連接指定數組的元素或集合的成員，分隔符位於每個元素或成員之間。

重載

參數

返回值

異常

示例

以下示例演示了使用 Char 和 String 連接一個 String[ ]。

string [ ] ZFCs = [ "蘿蔔" , "青菜" , "花" , "豬頭肉" , "雞蛋" , "韭菜" , "醬油" , "香油" , "陳醋" , "花生油" ];

string zfcChar = string . Join ( '+' , ZFCs );
Console . WriteLine ( zfcChar );

string zfcString = string . Join ( " + " , ZFCs );
Console . WriteLine ( zfcString );

string zfcChar23 = string . Join ( '+' , ZFCs , 2 , 3 );
Console . WriteLine ( zfcChar23 );

string zfcString23 = string . Join ( " + " , ZFCs , 2 , 3 );
Console . WriteLine ( zfcString23 );

object [ ] DXs = [ 123 , "321" , DateTime . Now , new StringBuilder ( "StringBuilder" ) , ( long ) 1234567890987654321 ];

string zfcDXChar = string . Join ( "+" , DXs );
Console . WriteLine ( zfcDXChar );

string zfcDXString = string . Join ( " + " , DXs );
Console . WriteLine ( zfcDXString );

ReadOnlySpan < object? > fwDX = DXs . AsSpan ( );
string zfcFWDx = string . Join ( " + " , fwDX );
Console . WriteLine ( zfcFWDx );

ReadOnlySpan < string? > fwString = ZFCs . AsSpan ( );
string zfcFWString = string . Join ( " + " , fwString );
Console . WriteLine ( zfcFWString );

IEnumerable < string > MJzfcs = ZFCs . AsEnumerable ( );
string zfcMJzfcs = string . Join ( " + " , MJzfcs );
Console . WriteLine ( zfcMJzfcs );

// 我的襪子收藏
List<string> WaZis =
[
    "白色運動襪",
    "黑色商務襪",
    "條紋休閒襪",
    "卡通圖案襪"
];

// 使用逗號分隔連接
string zfcWaZis = string . Join ('，' , WaZis );
Console . WriteLine ( $"我的襪子：{zfcWaZis}" );

備註

如果 連接符 為 null 或 String . Empty，則 連接符 為 String . Empty；若 連接對象 中某個對象是 null，則連接的是 String . Empty。

Join ( String , IEnumerable < String > ) 是一個便捷方法，可讓您連接 IEnumerable ( Of String ) 集合中的每個元素，而無需先將這些元素轉換為字符串數組。它在語言集成查詢（LINQ）查詢表達式中特別有用。以下示例將一個 List ( Of String ) 對象（其中包含字母表的大寫字母或小寫字母）傳遞給一個 lambda 表達式，該表達式選擇等於或大於特定字母（在本示例中為 “M”）的字母。Enumerable . Where 方法返回的 IEnumerable ( Of String ) 集合被傳遞給 Join ( String , Enumerable < String > ) 方法，以將結果顯示為單個字符串。

using System;
using System . Collections . Generic;
using System . Linq;

public class Example
{
   public static void Main()
   {
      string output = String . Join ( " " ,  GetAlphabet ( true ) . Where ( letter => 
                      letter . CompareTo ( "M" ) >= 0 ) );
      Console . WriteLine ( output );  
   }

   private static List < string > GetAlphabet ( bool upper )
   {
      List < string > alphabet = new List < string > ( );
      int charValue = upper ? 65 : 97;
      for ( int ctr = 0 ; ctr <= 25 ; ctr++ )
         alphabet . Add ( ( ( char ) ( charValue + ctr ) ) . ToString ( ) );
      return alphabet; 
   }
}
// The example displays the following output:
//      M N O P Q R S T U V W X Y Z

對調用者的説明

僅適用於 .NET Framework：如果 連接對象 的第一個元素為 null，則 Join ( String , Object [ ] ) 方法不會連接 連接對象 中的元素，而是返回 Empty。有多種方法可以解決此問題。最簡單的方法是為數組的第一個元素賦值 Empty，如下例所示。

object[] values = { null, "Cobb", 4189, 11434, .366 };
if (values[0] == null) values[0] = String.Empty;
Console.WriteLine(String.Join("|", values));

// The example displays the following output:
//      |Cobb|4189|11434|0.366

String . PadLeft 和 String . PadRight

返回一個新字符串，其中當前 實例 的開頭（Left）或末尾（Right）用空格或指定的 Unicode 字符填充。

重載

參數

返回值

異常

示例

using System . Text

Console . OutputEncoding = UTF8Encoding . UTF8;
string zfc左 = "左三圈" , zfc右 = "右三圈";
string zfc屁股 = "脖子扭扭，屁股扭扭";
zfc左 = zfc左 . PadRight ( 17 ) + Environment . NewLine;
zfc右 = zfc右 . PadLeft ( 17 ) + Environment . NewLine;
zfc屁股 = zfc屁股 . PadLeft ( 13 , '←' );
zfc屁股 = zfc屁股 . PadRight ( 17 , '→' );
Console . WriteLine ( zfc左 + zfc右 + zfc屁股 );

備註

PadLeft 和 PadRight 會在字符串起始或末尾添加空格或指定字符，意即，當語言環境為從右到左時，兩個方法與從左到右語言環境處理方式相反！

String . Remove

返回一個新字符串，其中從當前字符串中刪除了一定數量的字符。

public string Remove ( int 起始索引 );
public string Remove ( int 起始索引 , int 字符數 );

參數

返回值

異常

示例

string zfc = "Time is over now.";
int zhs2dian = 0;
while ( zhs2dian != 7 )
    {
    zhs2dian ++;
    zhs2dian = zfc . IndexOf ( ' ', zhs2dian );
    }
string zfc結果 = zfc . Remove ( zhs2dian , 5 );
Console . WriteLine ( zfc結果 );

備註

在 .NET Framework 中，字符串索引是從零開始的。起始索引 參數的值範圍可以是從 [ 0 , 實例 . Length - 1 ] 數。

注意：此方法不會修改當前實例的值。相反，它會返回一個新字符串，其中已移除由 字符數 參數指定數量的字符或起始索引之後的所有字符。這些字符是從 起始索引 指定的位置開始移除的。

String . Replace

返回一個新字符串，其中當前字符串中所有出現的指定 Unicode 字符或字符串都被另一個指定的 Unicode 字符或字符串替換。

重載

參數

返回值

異常

示例

下面的示例演示了 Replace ( char , char )，將空格替換為中文的驚歎號。

string zfc = "朕 越 來 越 不 信 任 A I 了";
Console . WriteLine ( $"原始字符串：\"{zfc}\"" );
Console . WriteLine ( $"玩笑字符串：\"{zfc . Replace ( ' ' , '!' )}\"" );

由於此方法會返回修改後的字符串，因此你可以將對 Replace 方法的連續調用鏈接起來，對原始字符串執行多次替換。方法調用從左到右執行。下面的示例對此進行了説明。

string zfc = new( '我' , 3 );
Console . WriteLine ( $"原始字符串：‘{zfc}’" );
zfc = zfc . Replace ( '我' , '你' ) . Replace ( '你' , '他' ) . Replace ( '他' , '她' );
Console . WriteLine ( $"最終字符串：‘{zfc}’" );

以下示例展示瞭如何使用 Replace 方法來糾正拼寫錯誤。

string zfcCuo = "This docment uses 3 other docments to docment the docmentation";
Console . WriteLine ( $"原始的有錯字符串：\n{zfcCuo}\n" );

string zfcXiu = zfcCuo . Replace ( "docment" , "document" );
Console . WriteLine ( $"修復的無錯字符串：{zfcXiu}" );

備註

當未指定 ber區分大小寫 或 比較選項 和 區域 參數時，搜索 zf舊 或 zfc舊 均使用序數（區分大小寫且不區分區域性）方式（指定參數均為 Char 時沒有 ber區分大小寫、比較選項 和 區域 參數）。

注意：此方法不會修改當前實例的值。相反，它會返回一個新字符串，其中所有出現的 zf舊 或 zfc舊 都被 zf新 或 zfc新 替換。

如果 zfc新 為 null 或 String . Empty，搜索到的 zfc舊 實際被移除。

StringComparison 參數可以選擇搜索 zfc舊 時使用的區域性（固定、當前或序號）及是否區分大小寫。若要使用某區域性字符串特徵，請使用 ber區分大小寫 和 區域 參數的方法。

String . ReplaceLineEndings

將當前字符串中的所有換行序列替換為當前平台默認 NewLine；或者指定字符串（例如 HTML 常用的 < br >）。

public string ReplaceLineEndings ( );
public string ReplaceLineEndings ( string 替換文本 );

參數

返回值

示例

以下示例替換了字符串中的非默認換行序列。

最終版本，就這麼發表了：
string zfc = "\n我要瘋了\r";

Console . WriteLine ( "未統一換行符：" );
Console . WriteLine ( zfc );
char [ ] ZFs = zfc . ToCharArray ( );
foreach ( char zf in ZFs )
    {
    Console . WriteLine ( Convert . ToString ( zf , 16 ) );
    }

Console . WriteLine ( "統一換行符：" );
zfc = zfc . ReplaceLineEndings ( );
Console . WriteLine ( zfc );
ZFs = zfc . ToCharArray ( );
foreach ( char zf in ZFs )
    {
    Console . WriteLine ( Convert . ToString ( zf , 16 ) );
    }

Console . WriteLine ( "統一換行符（HTML 常用）：" );
zfc = zfc . ReplaceLineEndings ( "<br>" );
Console . WriteLine ( zfc );
ZFs = zfc . ToCharArray ( );
foreach ( char zf in ZFs )
    {
    Console . WriteLine ( Convert . ToString ( zf , 16 ) );
    }

備註

通常有 7 種不同的換行序列：

• CR (U+000D) - 回車
• LF (U+000A) - 換行
• CRLF (U+000D U+000A) - 回車 + 換行
• NEL (U+0085) - 下一行
• LS (U+2028) - 行分隔符
• FF (U+000C) - 換頁
• PS (U+2029) - 段落分隔符

此方法會搜索字符串中的所有換行序列，並將其規範化以匹配當前環境的換行序列或用户指定的 替換文本（可以是 String . Empty）。例如無參數的該方法，在 Windows 系統上運行時，所有非 Windows 換行序列都會被替換為 CRLF 序列；在 Unix 系統上運行時，所有非 Unix 換行序列都會被替換為單個 LF 字符。

不建議協議解析器使用此 API。協議規範通常會規定特定的換行序列。例如，HTTP/1.1（RFC 8615）規定請求行、狀態行和頭行必須以 CRLF 結尾。由於此 API 適用於多種換行序列，使用此 API 的協議解析器可能會出現協議作者未預料到的行為。

此方法保證具有 O（n × r） 複雜度，其中 n 是輸入字符串的長度，r 是 替換文本 的長度。

String . Split

返回一個字符串數組，該數組包含此實例中由指定字符串或 Unicode 字符數組的元素分隔的子字符串。

重載

Split 用於將帶分隔符的字符串拆分為子字符串。您可以使用字符數組或字符串數組來指定零個或多個分隔字符或字符串。如果未指定分隔字符，字符串將在空白字符處拆分。

Split 方法的重載允許您限制該方法返回的子字符串數量（Split ( Char [ ] , Int32 )方法）、指定是否在結果中包含空字符串和/或修剪子字符串（Split ( Char [ ] , StringSplitOptions ) 和 Split ( String [ ] , StringSplitOptions ) 方法），或者同時執行這兩項操作（Split ( Char [ ] , Int32 , StringSplitOptions ) 和 Split ( String [ ] , Int32 , StringSplitOptions ) 方法）。

提示:Split 方法並不總是將帶分隔符的字符串拆分為子字符串的最佳方式。如果不想提取帶分隔符字符串的所有子字符串，或者希望基於模式而非一組分隔符字符來解析字符串，可以考慮使用正則表達式，或者將返回字符索引的某種搜索方法與 Substring 方法結合使用。

示例

以下示例展示了 String . Split ( ) 的三種不同重載。示例調用了 Split ( Char ) 和 Split ( Char [ ] ) 重載 和 Split ( String [ ] , StringSplitOptions )。

// 僅使用空格字符作為分隔符，分隔每個單詞，但句末的單詞會帶有句號
string zfc = "You win some. You lose some.";
char zfFGF = ' ';
string [ ] ZFCs = zfc . Split ( zfFGF );
foreach ( string z in ZFCs )
    { Console . WriteLine ( $"子字符串：{z}" ); }

// 使用字符空格和句號作為分隔符，由於句號後面是空格，所以會產生一個空字符串
char [ ] ZFsFGF = [ ' ', '.' ];
ZFCs = zfc . Split ( ZFsFGF );
foreach ( string z in ZFCs )
    { Console . WriteLine ( $"子字符串：{z}" ); }

// 使用字符空格、句點作為分隔符，並指定 StringSplitOptions 為 RemoveEmptyEntries，確保結果中沒有空字符串
ZFsFGF = [ ' ', '.' ];
ZFCs = zfc . Split ( ZFsFGF , StringSplitOptions . RemoveEmptyEntries );
foreach ( string z in ZFCs )
    { Console . WriteLine ( $"子字符串：{z}" ); }

參數

• 表格中的 或 為 |。

返回值

常見的空白字符包括：

• 空格字符 (' ', U+0020) - 最常見的空白字符
• 製表符 ('\t', U+0009) - 您提到的製表符，確實屬於空白字符
• 換行符 ('\n', U+000A) - 換行
• 回車符 ('\r', U+000D) - 回車
• 垂直製表符 ('\v', U+000B) - 垂直製表
• 換頁符 ('\f', U+000C) - 換頁

異常

示例

以下示例使用 StringSplitOptions 枚舉來包含或排除由 Split 方法生成的子字符串。

// 此示例演示使用 StringSplitOptions 枚舉的 String . Split ( ) 方法

// 示例 1：使用字符分隔符拆分字符串
Console . WriteLine ( "1) 使用字符分隔符拆分字符串：\n" );

string zfc原1 = ",ONE,, TWO,, , THREE,,";
char [ ] ZFs分隔符 = [','];
string [ ] ZFCs結果;

Console . WriteLine ( $"原始字符串為：\"{zfc原1}\"" );
Console . WriteLine ( $"分隔符為：'{ZFs分隔符 [ 0 ]}'\n" );

// 拆分字符串並返回所有元素
Console . WriteLine ( "1a) 返回所有元素：" );
ZFCs結果 = zfc原1 . Split ( ZFs分隔符 , StringSplitOptions . None );
FF顯示結果 ( ZFCs結果 );

// 拆分字符串並返回修剪空白後的所有元素
Console . WriteLine ( "1b) 返回修剪空白後的所有元素：" );
ZFCs結果 = zfc原1 . Split ( ZFs分隔符 , StringSplitOptions . TrimEntries );
FF顯示結果 ( ZFCs結果 );

// 拆分字符串並返回所有非空元素
Console . WriteLine ( "1c) 返回所有非空元素：" );
ZFCs結果 = zfc原1 . Split ( ZFs分隔符 , StringSplitOptions . RemoveEmptyEntries );
FF顯示結果 ( ZFCs結果 );

// 拆分字符串並返回修剪空白後的所有非空白元素
Console . WriteLine ( "1d) 返回修剪空白後的所有非空白元素：" );
ZFCs結果 = zfc原1 . Split ( ZFs分隔符 , StringSplitOptions . RemoveEmptyEntries | StringSplitOptions . TrimEntries );
FF顯示結果 ( ZFCs結果 );


// 將字符串拆分為僅兩個元素，餘下部分保留在最後一個匹配項中
Console . WriteLine ( "1e) 拆分為僅兩個元素：" );
ZFCs結果 = zfc原1 . Split ( ZFs分隔符 , 2 , StringSplitOptions . None );
FF顯示結果 ( ZFCs結果 );

// 將字符串拆分為僅兩個修剪空白的元素，餘下部分保留在最後一個匹配項中
Console . WriteLine ( "1f) 拆分為僅兩個修剪空白的元素：" );
ZFCs結果 = zfc原1 . Split ( ZFs分隔符 , 2 , StringSplitOptions . TrimEntries );
FF顯示結果 ( ZFCs結果 );

// 將字符串拆分為僅兩個非空元素，餘下部分保留在最後一個匹配項中
Console . WriteLine ( "1g) 拆分為僅兩個非空元素：" );
ZFCs結果 = zfc原1 . Split ( ZFs分隔符 , 2 , StringSplitOptions . RemoveEmptyEntries );
FF顯示結果 ( ZFCs結果 );

// 將字符串拆分為僅兩個修剪空白後的非空白元素，餘下部分保留在最後一個匹配項中
Console . WriteLine ( "1h) 拆分為僅兩個修剪空白後的非空白元素：" );
ZFCs結果 = zfc原1 . Split ( ZFs分隔符 , 2 , StringSplitOptions . RemoveEmptyEntries | StringSplitOptions . TrimEntries );
FF顯示結果 ( ZFCs結果 );


// 示例 2：使用字符串分隔符拆分字符串
Console . WriteLine ( "2) 使用字符串分隔符拆分字符串：\n" );

string zfc原2 = "[stop]" +
                "ONE[stop] [stop]" +
                "TWO  [stop][stop]  [stop]" +
                "THREE[stop][stop]  ";
string [ ] ZFCs分隔符 = ["[stop]"];

Console . WriteLine ( $"原始字符串為：\"{zfc原2}\"" );
Console . WriteLine ( $"分隔符字符串為：\"{ZFCs分隔符 [ 0 ]}\"\n" );

// 拆分字符串並返回所有元素
Console . WriteLine ( "2a) 返回所有元素：" );
ZFCs結果 = zfc原2 . Split ( ZFCs分隔符 , StringSplitOptions . None );
FF顯示結果 ( ZFCs結果 );

// 拆分字符串並返回所有修剪空白後的元素
Console . WriteLine ( "2b) 返回所有修剪空白後的元素：" );
ZFCs結果 = zfc原2 . Split ( ZFCs分隔符 , StringSplitOptions . TrimEntries );
FF顯示結果 ( ZFCs結果 );

// 拆分字符串並返回所有非空元素
Console . WriteLine ( "2c) 返回所有非空元素：" );
ZFCs結果 = zfc原2 . Split ( ZFCs分隔符 , StringSplitOptions . RemoveEmptyEntries );
FF顯示結果 ( ZFCs結果 );

// 拆分字符串並返回所有修剪空白後的非空白元素
Console . WriteLine ( "2d) 返回所有修剪空白後的非空白元素：" );
ZFCs結果 = zfc原2 . Split ( ZFCs分隔符 , StringSplitOptions . RemoveEmptyEntries | StringSplitOptions . TrimEntries );
FF顯示結果 ( ZFCs結果 );


// 將字符串拆分為僅兩個元素，餘下部分保留在最後一個匹配項中
Console . WriteLine ( "2e) 拆分為僅兩個元素：" );
ZFCs結果 = zfc原2 . Split ( ZFCs分隔符 , 2 , StringSplitOptions . None );
FF顯示結果 ( ZFCs結果 );

// 將字符串拆分為僅兩個修剪空白的元素，餘下部分保留在最後一個匹配項中
Console . WriteLine ( "2f) 拆分為僅兩個修剪空白的元素：" );
ZFCs結果 = zfc原2 . Split ( ZFCs分隔符 , 2 , StringSplitOptions . TrimEntries );
FF顯示結果 ( ZFCs結果 );

// 將字符串拆分為僅兩個非空元素，餘下部分保留在最後一個匹配項中
Console . WriteLine ( "2g) 拆分為僅兩個非空元素：" );
ZFCs結果 = zfc原2 . Split ( ZFCs分隔符 , 2 , StringSplitOptions . RemoveEmptyEntries );
FF顯示結果 ( ZFCs結果 );

// 將字符串拆分為僅兩個修剪空白後的非空白元素，餘下部分保留在最後一個匹配項中
Console . WriteLine ( "2h) 拆分為僅兩個修剪空白後的非空白元素：" );
ZFCs結果 = zfc原2 . Split ( ZFCs分隔符 , 2 , StringSplitOptions . RemoveEmptyEntries | StringSplitOptions . TrimEntries );
FF顯示結果 ( ZFCs結果 );


// 使用局部函數顯示分隔後的字符串數組
static void FF顯示結果 ( string [ ] ZFCs元素數組 )
    {
    int zhs元素數 = ZFCs元素數組 . Length;
    Console . WriteLine ( $"返回值包含 {zhs元素數} 個元素：" );

    foreach ( string zfc元素 in ZFCs元素數組 )
        {
        Console . Write ( $"<{zfc元素}>" );
        }
    Console . Write ( "\n\n" );
    }

以下示例説明了調用字符串的 String . Split ( String [ ] , StringSplitOptions )方法時，當 分隔選項 參數分別為 StringSplitOptions . None 和 StringSplitOptions . RemoveEmptyEntries 時，返回的數組之間的差異。

string zfc源字符串 = "[stop]ONE[stop][stop]TWO[stop][stop][stop]THREE[stop][stop]";
string [ ] ZFCs分隔符 = ["[stop]"];
string [ ] ZFCs結果;

// 顯示原始字符串和分隔符字符串
Console . WriteLine ( $"拆分字符串：\n   \"{zfc源字符串}\"" );
Console . WriteLine ( );
Console . WriteLine ( $"使用的分隔符字符串：\n   \"{ZFCs分隔符 [ 0 ]}\"" );
Console . WriteLine ( );

// 使用字符串分隔符拆分字符串並返回所有元素
ZFCs結果 = zfc源字符串 . Split ( ZFCs分隔符 , StringSplitOptions . None );
Console . WriteLine ( $"包含所有元素的結果（{ZFCs結果 . Length} 個元素）：" );
Console . Write ( "   " );
foreach ( string zfc元素 in ZFCs結果 )
    {
    Console . Write ( "'{0}' " , string . IsNullOrEmpty ( zfc元素 ) ? "<>" : zfc元素 );
    }
Console . WriteLine ( );
Console . WriteLine ( );

// 使用字符串分隔符拆分字符串並返回所有非空元素
ZFCs結果 = zfc源字符串 . Split ( ZFCs分隔符 , StringSplitOptions . RemoveEmptyEntries );
Console . WriteLine ( $"包含非空元素的結果（{ZFCs結果 . Length} 個元素）：" );
Console . Write ( "   " );
foreach ( string zfc元素 in ZFCs結果 )
    {
    Console . Write ( "'{0}' " , string . IsNullOrEmpty ( zfc元素 ) ? "<>" : zfc元素 );
    }
Console . WriteLine ( );

以下示例定義了一個包含標點符號和空白字符的分隔符數組。將此數組與 StringSplitOptions . RemoveEmptyEntries 值一起傳遞給 Split ( String [ ] , StringSplitOptions ) 方法，會返回一個由字符串中的各個單詞組成的數組。

// 定義分隔符數組，包含常見標點符號和空格
string [ ] ZFCs分隔符 = { ",", ".", "!", "?", ";", ":", " " };

// 待分割的英文句子
string zfc原文 = "The handsome, energetic, young dog was playing with his smaller, more lethargic litter mate.";

// 使用分隔符分割字符串，並移除空元素
string [ ] ZFCs單詞數組 = zfc原文 . Split ( ZFCs分隔符 , StringSplitOptions . RemoveEmptyEntries );

// 遍歷並輸出所有非空單詞
foreach ( string zfc單詞 in ZFCs單詞數組 )
    Console . WriteLine ( zfc單詞 );

以下示例展示瞭如何使用 count 來限制 Split 返回的字符串數量。

// 分割姓名示例
string zfc姓名 = "Alex Johnson III";

// 使用 null 分隔符（按空白字符分割），最多分割為2部分
string [ ] ZFCs部分 = zfc姓名 . Split ( null , 2 );

string zfc名 = ZFCs部分 [ 0 ];
string zfc姓;

if ( ZFCs部分 . Length > 1 )
{
    zfc姓 = ZFCs部分 [ 1 ];
}
else
{
    zfc姓 = "（無）";
}

// 結果顯示代碼
Console . WriteLine ( "=== 姓名分割結果演示 ===" );
Console . WriteLine ( $"原始姓名：{zfc姓名}" );
Console . WriteLine ( $"分割部分數：{ZFCs部分 . Length}" );
Console . WriteLine ( );

Console . WriteLine ( "分割後的各部分：" );
for ( int zhs索引 = 0 ; zhs索引 < ZFCs部分 . Length ; zhs索引++ )
{
    Console . WriteLine ( $"  部分{zhs索引 + 1}：'{ZFCs部分 [ zhs索引 ]}'" );
}
Console . WriteLine ( );

Console . WriteLine ( "結構化信息：" );
Console . WriteLine ( $"  名：{zfc名}" );
Console . WriteLine ( $"  姓：{zfc姓}" );
Console . WriteLine ( );

// 驗證分割邏輯
Console . WriteLine ( "=== 分割邏輯驗證 ===" );
Console . WriteLine ( $"ZFCs部分.Length > 1 的結果：{ZFCs部分 . Length > 1}" );
if ( ZFCs部分 . Length > 1 )
{
    Console . WriteLine ( "執行了 if 分支：zfc姓 = ZFCs部分[1]" );
}
else
{
    Console . WriteLine ( "執行了 else 分支：zfc姓 = \"（無）\"" );
}

備註

分隔符字符串不包含在返回數組的元素中。

如果該實例不包含 分隔符（組）中的任何字符串，或者 子字符串數 參數為 1，則返回的數組由一個包含該實例的元素組成。

如 實例 的起始或結尾處即為分隔符，或者任意連續兩個分隔符之間，若不指定 StringSplitOptions 或將其指定為 None 或僅 TrimEntries，則返回值數組中將在此位置包含一個空字符串。例如字符串 “-_aa-_”，若指定的分隔符組包含 ‘-’ 和 ‘_’ 兩個字符，則 Split 將返回有五個元素的字符串數組：

1. String . Empty：首字符 “-” 即分隔符產生的空字符串；
2. String . Empty：首字符 “-” 與 “_” 之間沒有內容產生的空字符串；
3. aa：“_” 與 “-” 之間的 aa；
4. String . Empty：索引 4 字符 “-” 與 索引 5 字符 “_” 之間沒有內容產生的空字符串；
5. String . Empty：尾字符 “_” 即分隔符產生的空字符串。

如果 分隔符（組）參數為 null 或不包含任何字符（串），則假定空白字符為分隔符。空白字符由 Unicode 標準定義，即若將其傳遞給 Char . IsWhiteSpace 方法，該方法會返回 true。

若要為 string? [ ] 分隔符組 或 Char? [ ] 分隔符組 參數傳遞 null，必須指明 null 的類型，以將此調用與其他一些重載（如 Split ( Char [ ] , Int32 , StringSplitOptions )）區分開來。以下示例展示了幾種明確指定此重載的方法。

string phrase = "The quick  brown fox";

_ = phrase . Split ( default (string [ ] ) , 3 , StringSplitOptions . RemoveEmptyEntries );
_ = phrase . Split ( ( string [ ]? ) null , 3 , StringSplitOptions . RemoveEmptyEntries );
_ = phrase . Split ( null as string [ ] , 3 , StringSplitOptions . RemoveEmptyEntries );

如果 子字符串數 參數為零，或者 StringSplitOptions 參數為 RemoveEmptyEntries 且此實例的長度為零，則返回一個空數組。

分隔符（組）的每個元素都定義了一個單獨的分隔符，該分隔符由一個或多個字符組成。如果 StringSplitOptions 參數為 None，且兩個分隔符相鄰，或者在該實例的開頭或結尾處發現了一個分隔符，則相應的數組元素包含空。

如果 實例 中的子字符串數量超過 子字符串數，則前 子字符串數 - 1 個子字符串會返回在返回值的前 子字符串 - 1 個元素中，而此實例中的剩餘字符會返回在返回值的最後一個元素中。

如果 子字符串數 大於子字符串的數量，則返回可用的子字符串，且不拋出異常。

分隔符組

如果 分隔符（組）中的任何元素由多個字符組成，則整個子字符串會被視為一個分隔符。例如，如果 分隔符（組）中的某個元素是 “10”，那麼嘗試拆分字符串 “This10is10a10string.” 會返回一個包含四個元素的數組：{ “This” , “is” , “a” , ，“string.” }。

比較詳情

Split 方法提取此字符串中由 分隔符（組）參數中的一個或多個字符串分隔的子字符串，並將這些子字符串作為數組的元素返回。

Split 方法通過使用區分大小寫的序號排序規則進行比較來查找分隔符。

Split 方法會忽略 分隔符（組）中值為 null 或空字符串（""）的任何元素。

以下表格展示了一些示例。

為避免當 分隔符組 中的字符串包含相同字符時出現模糊結果，Split 方法會從實例值的開頭遍歷到結尾，並匹配 分隔符組 中與實例中的分隔符相等的第一個元素。在實例中遇到子字符串的順序優先於 分隔符組 中元素的順序。

例如，考慮一個值為 “abcdef” 的實例。如果 分隔符組 中的第一個元素是 “ef”，第二個元素是 “bcde”，那麼拆分操作的結果將是 “a” 和 “f”。這是因為在實例中，子字符串 “bcde” 會先於子字符串 “f” 被遇到，並且與 分隔符組 中的某個元素匹配。

然而，如果 分隔符組 的第一個元素是 “bcd”，第二個元素是 “bc”，那麼拆分操作的結果將是 “a” 和 “ef”。這是因為 “bcd” 是 分隔符組 中第一個與實例中的分隔符相匹配的元素。如果顛倒分隔符的順序，使第一個元素為 “bc”，第二個元素為 “bcd”，那麼結果將是 “a” 和 “def”。

性能注意事項

Split 方法會為返回的數組對象以及每個數組元素對應的 String 對象分配內存。如果你的應用程序需要最佳性能，或者內存分配管理在應用程序中至關重要，那麼可以考慮使用 IndexOf 或 IndexOfAny 方法，也可以酌情使用 Compare 方法來在字符串中查找子字符串。

如果要按分隔符字符拆分字符串，請使用 IndexOf 或 IndexOfAny 方法在字符串中定位分隔符字符。如果要按分隔符字符串拆分字符串，請使用 IndexOf 或 IndexOfAny 方法定位分隔符字符串的第一個字符。然後使用 Compare 方法確定該第一個字符之後的字符是否與分隔符字符串的其餘字符相等。

此外，如果在多個拆分方法調用中使用同一組字符來拆分字符串，可考慮創建一個單獨的數組，並在每個方法調用中引用該數組。這能顯著減少每次方法調用的額外開銷。

致調用者的説明

在 .NET Framework 3.5 及更早版本中，如果向 Split ( Char [ ] ) 方法傳遞的 分隔符組 為 null 或不包含任何字符，該方法用於拆分字符串的空白字符集與 Trim ( Char [ ] ) 方法用於修整字符串的空白字符集略有不同。從 .NET Framework 4 開始，這兩種方法使用的 Unicode 空白字符集完全相同。

String . Substring

獲取實例中的子字符串。

重載

參數

返回值

異常

示例

以下示例演示瞭如何從字符串中獲取子字符串。

string [ ] ZFCs信息 = [ "姓名：周老三" , "稱號：半仙" , "年齡： 50" , "位置：山東省淄博市" , "性別：男" ];
int zhs找到了冒號;
Console . WriteLine ( "數組中的原始值：" );
foreach ( string zfc in ZFCs信息 )
    Console . WriteLine ( zfc );

Console . WriteLine ( "\n我們只需要信息，不需要標題哈：" );
foreach ( string zfc in ZFCs信息 )
    {
    zhs找到了冒號 = zfc . IndexOf ( '：' ) + 1;
    Console . Write ( $"    {zfc [ zhs找到了冒號.. ]}" );
    }
Console . WriteLine ( );

以下示例使用 Substring 方法來分隔由等號（ = ）字符分隔的鍵/值對。

String [ ] ZFCs衣櫥 = { "顏色 1 = 紅", "顏色 2 = 綠", "顏色 3 = 藍", "標題 = 衣服庫" };
foreach ( var yi in ZFCs衣櫥 )
    {
    int zhs等號位置 = yi . IndexOf (" = " );
    if ( zhs等號位置 < 0 )
        continue;
    Console . WriteLine ( $"鍵：{yi [ .. zhs等號位置 ]}，值：‘{yi [ ( zhs等號位置 + 3 ) .. ]}’" );
    }

以下示例在三種情況下使用 Substring ( Int32 , Int32 ) 方法來從字符串中提取子字符串。其中兩種情況中，子字符串用於比較；第三種情況中，由於指定了無效參數，會拋出異常。

1. 它提取字符串中第三個位置（索引為 2 處）的單個字符，並將其與 “c” 進行比較。該比較返回 true。
2. 它從字符串的第四個位置（索引 3 處）開始提取零個字符，並將其傳遞給 IsNullOrEmpty 方法。這會返回 true，因為對 Substring 方法的調用返回了 String . Empty。
3. 它嘗試從字符串的第四個位置開始提取一個字符。由於該位置沒有字符，此方法調用會拋出一個 ArgumentOutOfRangeException 異常。

string zfc = "abc";
bool cs1 = zfc . Substring ( 2 , 1 ) . Equals ( "c" ); // true.
Console . WriteLine ( cs1 );
bool cs2 = string . IsNullOrEmpty (zfc . Substring ( 3, 0 ) ); // true.
Console . WriteLine ( cs2 );
try
    {
    string zfccs = zfc . Substring ( 3 , 1 ); // 拋出異常 ArgumentOutOfRangeException
    Console . WriteLine ( zfccs );
    }
catch ( ArgumentOutOfRangeException YC )
    {
    Console . WriteLine ( YC . Message );
    }

備註

你可以調用 Substring ( Int32 ) 方法從字符串中提取子字符串，該子字符串從指定的字符位置開始，到字符串末尾結束。起始字符位置是從零開始的；換句話説，字符串中的第一個字符位於索引 0 處，而不是索引 1 處。若要提取從指定字符位置開始且在字符串末尾之前結束的子字符串，請調用 Substring ( Int32 , Int32 ) 方法。

注意：此方法不會修改當前實例的值。相反，它會返回一個新字符串，該字符串從當前字符串的 startIndex 位置開始，到指定 字符數 處或 實例 末尾結束。

特別提示：.NET 8 以上版本提供了範圍運算符（..）。示例中，多次使用範圍運算符代替了 Substring，並獲得更強大的靈活性和可讀性。例如：

string zfc = "123";
string zfc1 = zfc . Substring ( 0 ); // 123，.NET 會提示你用範圍運算符簡化
string zfc2 = zfc [ 0 .. ]; // 123，範圍運算符即 0 到末尾

詳情請見 “C# 的運算符” 一文中的 “範圍運算符”。

要提取以特定字符或字符序列開頭的子字符串，請調用 IndexOf 或 IndexOf 等方法來獲取 起始索引 的值。上述示例説明了這一點，它提取了一個鍵值，該鍵值從 （ = ） 字符後的一個字符位置開始。

若指定 字符數 參數，則 起始索引 + 字符數 - 1 處的字符不屬於 Substring 的返回值內容。
如果子字符串需要從 起始索引 延伸到指定的字符序列，你可以調用 IndexOf 或 LastIndexOf 等方法來獲取結束字符或字符序列的索引。然後，你可以按以下方式將該值轉換為字符串中的索引位置：

• 如果你搜索的是一個用於標記子字符串結尾的單個字符，那麼 字符數 參數等於 末尾索引 - 起始索引 + 1，其中 末尾索引 是 IndexOf 或 LastIndexOf 方法的返回值。
• 如果您搜索了多個用於標記子字符串結尾的字符，那麼 字符數 參數等於 末尾索引 + 子字符串末尾索引 - 起始索引，其中 末尾索引 是 IndexOf 或 LastIndexOf 方法的返回值，子字符串末尾索引 是標記子字符串結尾的字符序列的長度。
• 如果該字符或字符序列未包含在子字符串的末尾，則 字符數 參數等於 末尾索引 - 起始索引，其中 末尾索引 是 IndexOf 或 LastIndexOf 方法的返回值。

如果 起始索引 等於零，且 字符數 等於當前字符串的長度，或未指定，此方法將返回未更改的原始字符串。

String . ToCharArray

將此實例中的字符複製到 Unicode 字符數組。

重載

參數

返回值

異常

示例

    string zfc = "012wxyz789";
    char [ ] ZFs;

    ZFs = zfc . ToCharArray ( 3 , 4 );
    Console . Write ( $"‘{zfc}’中的字母：" );
    Console . WriteLine ( ZFs );
    Console . WriteLine ( $"‘{zfc}’每一個字母是：" , zfc );
    foreach ( char c in ZFs )
        Console . WriteLine ( c );

備註

此方法會將字符串中的每個字符（即每個 Char 對象）複製到 Char 數組中。複製的第一個字符位於返回的字符數組的索引 0 處；複製的最後一個字符位於索引 數組 . Length - 1（或 字符數）處。

如果 字符數 為零，則返回的數組為空且長度為零。如果此實例為 null 或空字符串（""），則返回的數組為空且長度為零。

要從字符數組中的字符創建字符串，請調用 String ( Char [ ] ) 構造函數。

若要創建包含字符串中已編碼字符的字節數組，請實例化相應的 Encoding 對象並調用其 Encoding . GetBytes ( String ) 方法。.NET 中提供的一些標準編碼包括：

String . ToLower、String . ToLowerInvariant 和 String . ToUpper 、String . ToUpperInvariant

返回此字符串轉換為小寫（Lower）或大寫（Upper）形式的（Invariant，固定區域性的大小寫形式）副本。

重載

public string ToLower ( );
public string ToLower ( CultureInfo 區域 );
public string ToLowerInvariant ( );
public string ToUpper ( );
public string ToUpper ( CultureInfo 區域 );
public string ToUpperInvariant ( );

參數

| 參數 | 類型 | 註解 |
| 區域 | CultureInfo | 轉換為小寫或大寫形式時使用的區域性規則 |

返回值

示例

以下示例使用英語-美國和土耳其-土耳其文化將兩個大寫字符串轉換為小寫字符串，然後比較這些小寫字符串。這兩個大寫字符串基本相同，不同之處在於：一個字符串中每次出現 Unicode 拉丁大寫字母 I 時，另一個字符串中則包含帶點的拉丁大寫字母 I。

Console . OutputEncoding = Encoding . UTF8;

string zfc1 = "INDIGO";
// str2 = str1，但其中每個 “I” 字符都變為 “\u0130”（Unicode 編碼中的大寫拉丁 I 上加點）
string zfc2 = new ( ['\u0130' , 'N' , 'D' , '\u0130' , 'G' , 'O'] );
string zfc3 , zfc4;

Console . WriteLine ( $"zfc1 = ‘{zfc1}’" );

Console . WriteLine ( );
Console . WriteLine ( $"zfc1 {( ( string . CompareOrdinal ( zfc1 , zfc2 ) == 0 ) ? "＝" : "≠" )} zfc2。" );
FF編碼點 ( "zfc1" , zfc1 );
FF編碼點 ( "zfc2" , zfc2 );

Console . WriteLine ( );
// str3 是 str2 的小寫版本，遵循的是英語 - 美國文化規範
Console . WriteLine ( $"zfc3 = {zfc2} 的小寫版本，遵循英語 - 美國文化規範。" );
zfc3 = zfc2 . ToLower ( new CultureInfo ( "en-US" , false ) );

// str4 是 str2 的小寫版本，遵循的是土耳其語 - 土耳其文化規範
Console . WriteLine ( $"zfc4 = {zfc2} 的小寫版本，遵循土耳其語 - 土耳其文化規範。" );
zfc4 = zfc2 . ToLower ( new CultureInfo ( "tr-TR" , false ) );

// 比較 zfc3 和 zfc4 的代碼點
Console . WriteLine ( );
Console . WriteLine ( $"zfc3 {( ( string . CompareOrdinal ( zfc3 , zfc4 ) == 0 ) ? "＝" : "≠" )} zfc4。" );
FF編碼點 ( "zfc3" , zfc3 );
FF編碼點 ( "zfc4" , zfc4 );

static void FF編碼點 ( string 標題 , string 文本 )
    {
    Console . WriteLine ( $"{Environment . NewLine}在 {標題} - {文本} 中的代碼點為：" );
    foreach ( ushort wfhd in 文本 )
        {
        Console . Write ( $"{wfhd:X4}    " );
        }
    Console . WriteLine ( );
    }

以下示例調用 ToUpper 方法，將包含基本拉丁字母、Latin-1 補充字母和拉丁擴展 - A 字符集中每個字符的一系列單字符字符串轉換為大寫。然後，它會顯示那些大寫字符與其小寫字符不同的字符串。

Console . OutputEncoding = Encoding . UTF8;
Console . WriteLine ( "🎯 Unicode字符大小寫轉換映射表\n" );
Console . WriteLine ( "範圍：U+0020 到 U+FFFF | 格式：小寫 → 大寫\n" );

List<string> liebiao所有變化 = [ ];

// 收集所有變化
for ( int zhs = 0x20 ; zhs <= 0xFFFF ; zhs++ )
    {
    string zfc1 = ((char)zhs).ToString();
    string zfc1大寫 = zfc1.ToUpper();

    if ( zfc1 != zfc1大寫 )
        {
        string zfc條目 = $"{zfc1} (U+{zhs:X4}) → {zfc1大寫} (U+{Convert.ToUInt16(zfc1大寫[0]):X4})";
        liebiao所有變化 . Add ( zfc條目 );
        }
    }

// 分三欄顯示
int zhs每欄行數 = (liebiao所有變化.Count + 2) / 3; // 均分三欄

for ( int i = 0 ; i < zhs每欄行數 ; i++ )
    {
    for ( int j = 0 ; j < 3 ; j++ )
        {
        int zhs索引 = i + j * zhs每欄行數;
        if ( zhs索引 < liebiao所有變化 . Count )
            {
            Console . Write ( liebiao所有變化 [ zhs索引 ] . PadRight ( 35 ) );
            }
        }
    Console . WriteLine ( );
    }

Console . WriteLine ( $"\n📈 總計：{liebiao所有變化 . Count} 個字符存在大小寫變化" );

以下示例定義了一個字符串數組，其中包含一個單詞（均為星期二）的多種語言版本。ToLowerInvariant 方法用於在一個並行數組中填充每個單詞的不區分大小寫版本的元素。Array . Sort < TKey ,TValue > ( TKey [ ] , TValue [ ] , IComparer < TKey > ) 方法用於根據小寫數組中元素的順序對區分大小寫的數組進行排序，以確保無論使用何種語言，元素的顯示順序都保持一致。

Console . OutputEncoding = Encoding . UTF8;

string [ ] zfcZhou2s = [ "Tuesday" , "Salı" , "Вторник" , "Mardi" , "Τρίτη" , "Martes" , "יום שלישי" , "الثلاثاء" , "วันอังคาร" ];
// 顯示未排序的數組
foreach ( string zfcZ2 in zfcZhou2s )
    Console . WriteLine ( zfcZ2 );
Console . WriteLine ( );

// 通過調用 ToLowerInvariant 方法創建名為 zfcZhou2s 的平行數組
string [ ] zfcZhou2s小寫 = new string [ zfcZhou2s . Length ];
for ( int ctr = zfcZhou2s . GetLowerBound ( 0 ) ; ctr <= zfcZhou2s . GetUpperBound ( 0 ) ; ctr++ )
    zfcZhou2s小寫 [ ctr ] = zfcZhou2s [ ctr ] . ToLowerInvariant ( );

// 根據 “zfcZhou2s小寫” 的小寫形式的順序對 “zfcZhou2s” 數組進行排序
Array . Sort ( zfcZhou2s小寫 , zfcZhou2s , StringComparer . InvariantCulture );

// Display the sorted array.
foreach ( string zfcZ2 in zfcZhou2s )
    Console . WriteLine ( zfcZ2 );

註解

這些方法會考慮當前區域性或固定區域性的大小寫規則。

注意：這些方法不會修改當前實例的值。相反，它會返回一個新字符串，其中當前實例中的所有字符都轉換為小寫。

調用 ToLower ( ) 和 ToUpper ( ) 方法所產生的大小寫轉換操作會考慮當前區域性的大小寫約定。如果向 ToLower ( 區域 ) 和 ToUpper ( 區域 ) 方法傳遞 CultureInfo . InvariantCulture 以外的 CultureInfo 對象，大小寫轉換操作將考慮特定於區域性的規則。如果需要操作系統標識符（如文件名、命名管道或註冊表項）的小寫或大寫版本，請使用 ToLowerInvariant 或 ToUpperInvariant 方法。這會在所有區域性中產生相同的結果（與 ToLower ( ) 和 ToUpper 方法不同），並且執行效率更高。

固定區域性表示一種不區分區域性的區域性。它與英語相關聯，但不與特定國家或地區相關聯。

如果你的應用程序依賴於字符串的大小寫以可預測的方式變化，且不受當前區域性的影響，請使用 ToLowerInvariant 和 ToUpperInvariant 方法。ToLowerInvariant 和 ToUpperInvariant 方法等同於 ToLower ( CultureInfo . InvariantCulture ) 和 ToUpper ( CultureInfo . InvariantCulture )。當用户界面控件中的字符串集合必須以可預測的順序顯示時，建議使用此方法。

調用者注意事項

正如《使用字符串的最佳實踐》中所解釋的，我們建議您避免調用替換默認值的字符串大小寫方法，而是調用需要顯式指定參數的方法。要使用當前區域性的大小寫約定將字符轉換為小寫，請通過為其 區域 參數傳遞 CurrentCulture 值來調用 ToLower ( 區域 ) 和 ToUpper ( 區域 ) 方法重載，以明確表達您的意圖。如果不需要語言感知的比較，請考慮使用 Ordinal。

Trim、TrimEnd 和 TrimStart

通過移除 實例 中的所有前導、後綴的指定字符或空白字符（Trim）；移除 實例 中的所有後綴字符或空白字符（TrimEnd）；移除 實例 中的所有前導字符或空白字符（TrimStart），返回一個新字符串。

重載

提示：Trim、TrimEnd 和 TrimStart 均不會對 實例 中的指定字符或空白字符移除，例如 "acbc" . TrimEnd ( 'c' ) 返回 acb 而不是 ab。

public string Trim ( );
public string Trim ( Char 修剪字符 );
public string Trim ( char [ ] 修剪字符數組 );
public string TrimEnd ( );
public string TrimEnd ( Char 修剪字符 );
public string TrimEnd ( char [ ] 修剪字符數組 );
public string TrimStart ( );
public string TrimStart ( Char 修剪字符 );
public string TrimStart ( char [ ] 修剪字符數組 );

參數

返回值

示例

以下示例使用 TrimEnd ( ) 方法去除字符數數組每個元素的後綴空格。

Console . OutputEncoding = Encoding . UTF8;

string [ ] ZFCs = [ "I like   " , "    Like me" , "    Like this    " , "    " , "a b c d" , "a  b  c  d  " ];
string zfc修剪;
foreach ( string zfc in ZFCs )
    {
    zfc修剪 = zfc . TrimEnd ( );
    Console . WriteLine ( $"{zfc}（{zfc . Length}）修剪成：{zfc修剪}（{zfc修剪 . Length}）" );

以下示例使用 TrimStart ( ) 方法去除字符數數組每個元素的前綴字符（!）。

Console . OutputEncoding = Encoding . UTF8;

string [ ] ZFCs = [ "!like   " , "! ! ! ! Like me" , "!!! !   Like this    " , "! ! ! ! " , "!a !!b !!!c !!!!d" ];
string zfc修剪;
foreach ( string zfc in ZFCs )
    {
    zfc修剪 = zfc . TrimStart ( '!' );
    Console . WriteLine ( $"{zfc}（{zfc . Length}）修剪成：{zfc修剪}（{zfc修剪 . Length}）" );
    }

以下示例使用 TrimStart ( ) 方法從源代碼行中剪裁空白和註釋字符。StripComments 方法封裝了對 TrimStart 的調用，並向其傳遞一個字符數組，該數組包含一個空格和註釋字符，在Visual Basic中註釋字符是撇號（'），在C#或F#中是斜槓（/）。在判斷字符串是否為註釋時，也會調用TrimStart方法來移除前導空白。

Console . OutputEncoding = Encoding . UTF8;

string [ ] lines = ["using System;" , "" , "public class HelloWorld" , "{" , "   public static void Main ( )" , "   {" , "      // This code displays a simple greeting" , "      // to the console." , "      Console.WriteLine(\"Hello, World.\");" , "   }" , "}"];
Console . WriteLine ( "Before call to StripComments:" );
foreach ( string line in lines )
    Console . WriteLine ( "   {0}" , line );

string [ ] strippedLines = StripComments(lines);
Console . WriteLine ( "After call to StripComments:" );
foreach ( string line in strippedLines )
    Console . WriteLine ( "   {0}" , line );

static string [ ] StripComments ( string [ ] lines )
    {
    List<string> lineList =  [ ];
    foreach ( string line in lines )
        {
        if ( line . TrimStart ( ' ' ) . StartsWith ( "//" ) )
            lineList . Add ( line . TrimStart ( ' ' , '/' ) );
        }
    return [ .. lineList ];
    }

以下示例使用 Trim ( System . Char [ ] 修剪字符數組 ) 方法從字符串中移除空格、星號（※）和撇號（'）字符。

char [ ] zfs修剪 = [ '※', ' ', '\'' ];
string zfc = "※ ※ ※ Time is over now! Restart it? ※※※";
string zfc修剪 = zfc . Trim ( zfs修剪 );
Console . WriteLine ( $"修剪後\n    {zfc}\n成為\n    ‘{zfc修剪}’" );

備註

Trim、TrimEnd 和 TrimStart 方法會從當前 實例 中移除所有前導 和/ 或尾隨的 zf 或 zfs 指定的字符 或 空白字符。每個前導和尾隨的修剪操作都會在遇到非指定字符時停止。例如，如果當前字符串是“ abc xyz ”，則 Trim 方法會返回“abc xyz”。要移除字符串中單詞之間的空白字符，請使用 .NET 正則表達式。

注意：如果 Trim、TrimEnd 和 TrimStart 方法從當前實例中移除了任何字符，此方法不會修改當前實例的值。相反，它會返回一個新字符串，其中移除了 實例 中所有前導 和/或 尾隨的指定字符或空白字符。

如果 實例 等於 String . Empty，或者當前實例中的所有字符均由 zf 或 zfs 中的元素或 空白字符 組成，則該方法返回 String . Empty。

若參數 zfs（Char 數組）為 null 或空數組，Trim、TrimEnd 和 TrimStart 方法會以空白字符作為修剪字符。

空白字符由 Unicode 標準定義。無參數的 Trim、TrimEnd 和 TrimStart 方法會移除所有前導 和/或 尾隨字符，這些字符在傳遞給 Char . IsWhiteSpace 方法時會產生 true 的返回值。

調用者注意事項

.NET Framework 3.5 SP1 及更早版本會維護一個此方法要修剪的空白字符的內部列表。從 .NET Framework 4 開始，無參數的 Trim、TrimEnd 和 TrimStart 方法會修剪所有 Unicode 空白字符（即當傳遞給 IsWhiteSpace ( Char ) 方法時會返回 true 的字符）。由於這一變化，.NET Framework 3.5 SP1 及更早版本中的無參數的 Trim、TrimEnd 和 TrimStart 方法會移除兩個字符：零寬空格（U+200B）和零寬非斷空格（U+FEFF），而 .NET Framework 4 及更高版本中的無參數的 Trim、TrimEnd 和 TrimStart 方法不會移除這兩個字符。此外，.NET Framework 3.5 SP1 及更早版本中的無參數的 Trim、TrimEnd 和 TrimStart 方法不會修剪三個 Unicode 空白字符：蒙古語元音分隔符（U+180E）、窄非斷空格（U+202F）和中等數學空格（U+205F）。

String . TryCopyTo ( Span < Char > )

將此字符串的內容複製到目標 內存範圍 中。
public bool TryCopyTo ( Span < char > 目標 );

參數

返回值