StringComparison 枚举

定义

指定供 Compare(String, String)Equals(Object) 方法的特定重载使用的区域性、大小写和排序规则。

C#
public enum StringComparison
C#
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum StringComparison
继承
StringComparison
属性

字段

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.CompareString.EqualsString.IndexOf)时,应始终调用包含类型的 StringComparison 参数的重载,以便指定该方法执行的比较类型。 有关详细信息,请参阅有关使用字符串的最佳实践

使用单词排序规则的操作会执行区分区域性的比较,其中某些非幻象 Unicode 字符可能为其分配了特殊权重。 使用单词排序规则和特定区域性的约定,连字符 (“-”) 可能分配了非常小的权重,以便“coop”和“合作”出现在排序列表中彼此旁边。

备注

仅在 Linux 和 macOS 系统上运行的 .NET Core:C 和 Posix 区域性的排序规则行为始终区分大小写,因为这些区域性不使用预期的 Unicode 排序规则顺序。 建议使用除 C 或 Posix 以外的区域性执行区分区域性但不区分大小写的排序操作。

使用序号排序规则的操作基于字符串中每个 Char 代码点的数值 (Unicode 代码点) 执行比较。 序号比较很快,但区域性不区分。 使用序号排序规则对以 Unicode 字符开头的字符串进行排序时 (U+) ,如果 xxxx 的值小于 yyyy,则字符串 U+xxxx 位于字符串 U+yy 之前。

有关比较的详细信息,请参阅 System.String 类备注。 有关区域性的详细信息,请参阅 System.Globalization.CultureInfo 类备注。 有关何时使用序号或区域性敏感比较规则或固定区域性规则的指南,请参阅 使用字符串的最佳做法。 有关一组文本文件,其中包含用于对Windows操作系统的排序和比较操作中使用的字符权重的信息,请参阅“对权重表进行排序”。 有关 Linux 和 macOS 的排序权重表,请参阅 默认 Unicode 排序规则元素表

适用于

产品 版本
.NET Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7
.NET Framework 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8
.NET Standard 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1
UWP 10.0

另请参阅