StringComparison 列舉

定義

命名空間:

System

組件:

System.Runtime.dll

組件:

mscorlib.dll

組件:

netstandard.dll

指定 Compare(String, String) 和 Equals(Object) 方法的特定多載所要使用的文化特性、大小寫和排序規則。

C#

public enum StringComparison

C#

[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum StringComparison

繼承

Object

ValueType

Enum

StringComparison

屬性

ComVisibleAttribute SerializableAttribute

欄位

CurrentCulture	0	比較字串時，使用區分文化特性的排序規則和目前的文化特性。
CurrentCultureIgnoreCase	1	比較字串時，使用區分文化特性的排序規則和目前的文化特性，並且忽略要比較之字串的大小寫。
InvariantCulture	2	比較字串時，使用區分文化特性的排序規則，並且不因文化特性而異。
InvariantCultureIgnoreCase	3	比較字串時，使用區分文化特性的排序規則、不因文化特性而異，並且忽略要比較之字串的大小寫。
Ordinal	4	比較字串時，使用序數 (二進位) 排序規則。
OrdinalIgnoreCase	5	比較字串時，使用序數 (二進位) 排序規則，並且忽略要比較之字串的大小寫。

範例

下列範例會使用 列舉的每個 StringComparison 成員，比較三組字串。 比較使用英文 (美國) 、泰文 (泰文) 和土耳其文 (土耳其) 文化特性的慣例。 請注意，「a」 和 「a-」 字串在 「th-TH」 文化特性中被視為相等，但在其他文化特性中，「i」 和 「İ」 則視為在 「tr-TR」 文化特性中視為相等，但在其他文化特性中則視為相等。

C#

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

public class Example3
{
    public static void Main()
    {
        String[] cultureNames = { "en-US", "th-TH", "tr-TR" };
        String[] strings1 = { "a", "i", "case", };
        String[] strings2 = { "a-", "\u0130", "Case" };
        StringComparison[] comparisons = (StringComparison[])Enum.GetValues(typeof(StringComparison));

        foreach (var cultureName in cultureNames)
        {
            Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName);
            Console.WriteLine("Current Culture: {0}", CultureInfo.CurrentCulture.Name);
            for (int ctr = 0; ctr <= strings1.GetUpperBound(0); ctr++)
            {
                foreach (var comparison in comparisons)
                    Console.WriteLine("   {0} = {1} ({2}): {3}", strings1[ctr],
                                      strings2[ctr], comparison,
                                      String.Equals(strings1[ctr], strings2[ctr], comparison));

                Console.WriteLine();
            }
            Console.WriteLine();
        }
    }
}
// The example displays the following output:
//    Current Culture: en-US
//       a = a- (CurrentCulture): False
//       a = a- (CurrentCultureIgnoreCase): False
//       a = a- (InvariantCulture): False
//       a = a- (InvariantCultureIgnoreCase): False
//       a = a- (Ordinal): False
//       a = a- (OrdinalIgnoreCase): False
//
//       i = İ (CurrentCulture): False
//       i = İ (CurrentCultureIgnoreCase): False
//       i = İ (InvariantCulture): False
//       i = İ (InvariantCultureIgnoreCase): False
//       i = İ (Ordinal): False
//       i = İ (OrdinalIgnoreCase): False
//
//       case = Case (CurrentCulture): False
//       case = Case (CurrentCultureIgnoreCase): True
//       case = Case (InvariantCulture): False
//       case = Case (InvariantCultureIgnoreCase): True
//       case = Case (Ordinal): False
//       case = Case (OrdinalIgnoreCase): True
//
//
//    Current Culture: th-TH
//       a = a- (CurrentCulture): True
//       a = a- (CurrentCultureIgnoreCase): True
//       a = a- (InvariantCulture): False
//       a = a- (InvariantCultureIgnoreCase): False
//       a = a- (Ordinal): False
//       a = a- (OrdinalIgnoreCase): False
//
//       i = İ (CurrentCulture): False
//       i = İ (CurrentCultureIgnoreCase): False
//       i = İ (InvariantCulture): False
//       i = İ (InvariantCultureIgnoreCase): False
//       i = İ (Ordinal): False
//       i = İ (OrdinalIgnoreCase): False
//
//       case = Case (CurrentCulture): False
//       case = Case (CurrentCultureIgnoreCase): True
//       case = Case (InvariantCulture): False
//       case = Case (InvariantCultureIgnoreCase): True
//       case = Case (Ordinal): False
//       case = Case (OrdinalIgnoreCase): True
//
//
//    Current Culture: tr-TR
//       a = a- (CurrentCulture): False
//       a = a- (CurrentCultureIgnoreCase): False
//       a = a- (InvariantCulture): False
//       a = a- (InvariantCultureIgnoreCase): False
//       a = a- (Ordinal): False
//       a = a- (OrdinalIgnoreCase): False
//
//       i = İ (CurrentCulture): False
//       i = İ (CurrentCultureIgnoreCase): True
//       i = İ (InvariantCulture): False
//       i = İ (InvariantCultureIgnoreCase): False
//       i = İ (Ordinal): False
//       i = İ (OrdinalIgnoreCase): False
//
//       case = Case (CurrentCulture): False
//       case = Case (CurrentCultureIgnoreCase): True
//       case = Case (InvariantCulture): False
//       case = Case (InvariantCultureIgnoreCase): True
//       case = Case (Ordinal): False
//       case = Case (OrdinalIgnoreCase): True

備註

列舉 StringComparison 是用來指定字串比較是否應該使用目前的文化特性或不變異文化特性、單字或序數排序規則，以及區分大小寫或不區分大小寫。

重要

當您呼叫字串比較方法，例如 String.Compare 、 String.Equals 或 String.IndexOf 時，應該一律呼叫包含 型 StringComparison 別參數的多載，以便指定方法所執行的比較類型。 如需詳細資訊，請參閱使用字串的最佳做法。

使用字組排序規則的作業會執行區分文化特性的比較，其中某些非虛構 Unicode 字元可能會有特殊權數指派給它們。 使用特定文化特性的字組排序規則和慣例，連字號 (「-」) 可能會指派非常小的權數，如此一來，「coop」和「共同作業」就會出現在已排序的清單中彼此旁邊。

注意

僅在 Linux 和 macOS 系統上執行的 .Net Core： C 和 Posix 文化特性的定序行為一律會區分大小寫，因為這些文化特性不會使用預期的 Unicode 定序順序。 建議您使用 C 或 Posix 以外的文化特性來執行區分文化特性、不區分大小寫的排序作業。

使用序數排序規則的作業會根據字串中每個 Char 值的數值 (Unicode 字碼點執行比較) 。 序數比較快速但不區分文化特性。 當您使用序數排序規則來排序以 Unicode 字元開頭的字串 (U+) 時，如果 xxxx 的值數值小於 y，字串 U+yyy 字串就會出現在字串 U+y 之前。

如需比較的詳細資訊，請參閱 System.String 類別備註。 如需文化特性的詳細資訊，請參閱 System.Globalization.CultureInfo 類別備註。 如需何時使用序數或區分文化特性的比較規則或不變異文化特性規則的指導方針，請參閱 使用字串的最佳做法。 如需一組文字檔，其中包含用於排序和比較Windows作業系統之字元權數的資訊，請參閱排序權數資料表。 如需 Linux 和 macOS 的排序權數資料表，請參閱 預設 Unicode 定序元素資料表。

適用於

另請參閱

• String
• Compare(String, String)
• Compare(String, String)
• CompareOrdinal(String, String)
• InvariantCulture