CompareOptions Enumeração

Definição

Namespace:
System.Globalization
Assemblies:
mscorlib.dll, System.Globalization.dll
Assembly:
mscorlib.dll
Assembly:
System.Globalization.dll
Assembly:
netstandard.dll

Define as opções de comparação de cadeia de caracteres a serem usadas com CompareInfo.

Essa enumeração dá suporte a uma combinação bit a bit dos valores de membro.

public enum class CompareOptions
[System.Flags]
public enum CompareOptions
[System.Flags]
[System.Serializable]
public enum CompareOptions
[System.Flags]
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public enum CompareOptions
[<System.Flags>]
type CompareOptions = 
[<System.Flags>]
[<System.Serializable>]
type CompareOptions = 
[<System.Flags>]
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type CompareOptions = 
Public Enum CompareOptions
Herança
Object
ValueType
Enum
CompareOptions
Atributos
FlagsAttribute SerializableAttribute ComVisibleAttribute

Campos

Nome Valor Description
None 0

Uma comparação de cadeia de caracteres com as configurações de opção padrão.
IgnoreCase 1

Uma comparação de cadeia de caracteres que ignora as diferenças de maiúsculas e minúsculas.
IgnoreNonSpace 2

Uma comparação de cadeia de caracteres que ignora o não espaçamento combinando caracteres, como diacríticos. Caracteres sem espaçamento modificam caracteres base sem ocupar seu próprio espaço. O Padrão Unicode define a combinação de caracteres como caracteres combinados com caracteres base para produzir um novo caractere.
IgnoreSymbols 4

Uma comparação de cadeia de caracteres que ignora símbolos, incluindo espaço em branco, pontuação, símbolos de moeda, o sinal de porcentagem, símbolos matemáticos, o e comercial e caracteres semelhantes.
IgnoreKanaType 8

Uma comparação de cadeia de caracteres que ignora o tipo kana. O tipo Kana refere-se aos caracteres hiragana e katakana japoneses, que representam sons fonéticos. Hiragana é usado para palavras nativas japonesas, enquanto katakana é usada para palavras emprestadas de outras línguas. Com essa opção, os caracteres hiragana e katakana que representam o mesmo som são considerados iguais.
IgnoreWidth 16

Uma comparação de cadeia de caracteres que ignora a largura do caractere. Por exemplo, formas de largura total e meia largura de caracteres katakana japoneses são consideradas iguais com essa opção.
OrdinalIgnoreCase 268435456

Uma comparação de cadeia de caracteres que ignora maiúsculas e minúsculas e, em seguida, executa uma comparação ordinal. Essa técnica é equivalente a converter a cadeia de caracteres em maiúscula usando a cultura invariável e, em seguida, executar uma comparação ordinal no resultado.

    This value can't be combined with other <xref data-throw-if-not-resolved="true" uid="System.Globalization.CompareOptions"></xref> values and must be used alone.
StringSort 536870912

Uma comparação de cadeia de caracteres que usa o algoritmo de classificação de cadeia de caracteres, em que símbolos não numéricos (como hifens e apóstrofos) são classificados antes dos caracteres alfanuméricos.
Ordinal 1073741824

Uma comparação de cadeia de caracteres que usa os valores codificados unicode UTF-16 das cadeias de caracteres, comparando-os unidade de código por unidade de código. Isso resulta em uma comparação rápida e sem diferenciação de cultura em que as cadeias de caracteres são ordenadas com base apenas em seus valores binários. Essa opção não pode ser combinada com outros CompareOptions valores e deve ser usada sozinha.

Exemplos

O exemplo de código a seguir mostra como cada um dos valores afeta as CompareOptions comparações de cadeia de caracteres.

using System;
using System.Globalization;

public class CompareOptionsExample
{
    public static void Run()
    {
        // Uppercase and lowercase characters are equivalent (according to the culture rules)
        // when IgnoreCase is used.
        TestStringEquality("ONE two", "one TWO", "Case sensitivity", CompareOptions.IgnoreCase);

        // Punctuation is ignored with the IgnoreSymbols option.
        TestStringEquality("hello world", "hello, world!", "Punctuation", CompareOptions.IgnoreSymbols);

        // Whitespace and mathematical symbols are also ignored with IgnoreSymbols.
        TestStringEquality("3 + 5 = 8", "358", "Whitespace and mathematical symbols", CompareOptions.IgnoreSymbols);

        // Caution: currency symbols and thousands separators are ignored with IgnoreSymbols.
        // Parse strings containing numbers/currency and compare them numerically instead.
        TestStringEquality("Total $15,000", "Total: £150.00", "Currency symbols, decimals and thousands separators", CompareOptions.IgnoreSymbols);

        // Full width characters are common in East Asian languages. Use the IgnoreWidth
        // option to treat full- and half-width characters as equal.
        TestStringEquality("ａｂｃ，－", "abc,-", "Half width and full width characters", CompareOptions.IgnoreWidth);

        // The same string in Hiragana and Katakana is equal when IgnoreKanaType is used.
        TestStringEquality("ありがとう", "アリガトウ", "Hiragana and Katakana strings", CompareOptions.IgnoreKanaType);

        // When comparing with the IgnoreNonSpace option, characters like diacritical marks are ignored.
        TestStringEquality("café", "cafe", "Diacritical marks", CompareOptions.IgnoreNonSpace);

        // Ligature characters and their non-ligature forms compare equal with the IgnoreNonSpace option.
        // Note: prior to .NET 5, ligature characters were equal to their expanded forms by default.
        TestStringEquality("straße œuvre cæsar", "strasse oeuvre caesar", "Ligature characters", CompareOptions.IgnoreNonSpace);
    }

    private static void TestStringEquality(string str1, string str2, string description, CompareOptions options)
    {
        Console.WriteLine(Environment.NewLine + description + ":");
        // First test with the default CompareOptions then with the provided options
        TestStringEquality(str1, str2, CompareOptions.None);
        TestStringEquality(str1, str2, options);
    }

    private static void TestStringEquality(string str1, string str2, CompareOptions options)
    {
        Console.Write($"  When using CompareOptions.{options}, \"{str1}\" and \"{str2}\" are ");
        if (string.Compare(str1, str2, CultureInfo.InvariantCulture, options) != 0)
        {
            Console.Write("not ");
        }
        Console.WriteLine("equal.");
    }
}

/*
In .NET 5 and later, the output is the following:
 
Case sensitivity:
  When using CompareOptions.None, "ONE two" and "one TWO" are not equal.
  When using CompareOptions.IgnoreCase, "ONE two" and "one TWO" are equal.

Punctuation:
  When using CompareOptions.None, "hello world" and "hello, world!" are not equal.
  When using CompareOptions.IgnoreSymbols, "hello world" and "hello, world!" are equal.

Whitespace and mathematical symbols:
  When using CompareOptions.None, "3 + 5 = 8" and "358" are not equal.
  When using CompareOptions.IgnoreSymbols, "3 + 5 = 8" and "358" are equal.

Currency symbols, decimals and thousands separators:
  When using CompareOptions.None, "Total $15,000" and "Total: £150.00" are not equal.
  When using CompareOptions.IgnoreSymbols, "Total $15,000" and "Total: £150.00" are equal.

Half width and full width characters:
  When using CompareOptions.None, "ａｂｃ，－" and "abc,-" are not equal.
  When using CompareOptions.IgnoreWidth, "ａｂｃ，－" and "abc,-" are equal.

Hiragana and Katakana strings:
  When using CompareOptions.None, "ありがとう" and "アリガトウ" are not equal.
  When using CompareOptions.IgnoreKanaType, "ありがとう" and "アリガトウ" are equal.

Diacritical marks:
  When using CompareOptions.None, "café" and "cafe" are not equal.
  When using CompareOptions.IgnoreNonSpace, "café" and "cafe" are equal.

Ligature characters:
  When using CompareOptions.None, "straße œuvre cæsar" and "strasse oeuvre caesar" are not equal.
  When using CompareOptions.IgnoreNonSpace, "straße œuvre cæsar" and "strasse oeuvre caesar" are equal.

Note: When using .NET versions prior to .NET 5, ligature characters compare as equal to their
non-ligature counterparts by default, so the last test will output as follows:

Ligature characters:
  When using CompareOptions.None, "straße œuvre cæsar" and "strasse oeuvre caesar" are equal.
  When using CompareOptions.IgnoreNonSpace, "straße œuvre cæsar" and "strasse oeuvre caesar" are equal.
*/

module compareoptions_values

open System
open System.Globalization

let testStringEquality (str1: string) (str2: string) (description: string) (options: CompareOptions) =
    printfn "\n%s:" description

    let compareAndPrint opts =
        let result = String.Compare(str1, str2, CultureInfo.InvariantCulture, opts)
        let equalityStatus = if result = 0 then "equal" else "not equal"
        printfn "  When using CompareOptions.%A, \"%s\" and \"%s\" are %s." opts str1 str2 equalityStatus

    compareAndPrint CompareOptions.None
    compareAndPrint options

[<EntryPoint>]
let main argv =
    // Uppercase and lowercase characters are equivalent (according to the culture rules) when IgnoreCase is used.
    testStringEquality "ONE two" "one TWO" "Case sensitivity" CompareOptions.IgnoreCase

    // Punctuation is ignored with the IgnoreSymbols option.
    testStringEquality "hello world" "hello, world!" "Punctuation" CompareOptions.IgnoreSymbols

    // Whitespace and mathematical symbols are also ignored with IgnoreSymbols.
    testStringEquality "3 + 5 = 8" "358" "Whitespace and mathematical symbols" CompareOptions.IgnoreSymbols

    // Caution: currency symbols and thousands separators are ignored with IgnoreSymbols.
    // Parse strings containing numbers/currency and compare them numerically instead.
    testStringEquality "Total $15,000" "Total: £150.00" "Currency symbols, decimals and thousands separators" CompareOptions.IgnoreSymbols

    // Full width characters are common in East Asian languages. Use the IgnoreWidth
    // option to treat full- and half-width characters as equal.
    testStringEquality "ａｂｃ，－" "abc,-" "Half width and full width characters" CompareOptions.IgnoreWidth

    // The same string in Hiragana and Katakana is equal when IgnoreKanaType is used.
    testStringEquality "ありがとう" "アリガトウ" "Hiragana and Katakana strings" CompareOptions.IgnoreKanaType

    // When comparing with the IgnoreNonSpace option, characters like diacritical marks are ignored.
    testStringEquality "café" "cafe" "Diacritical marks" CompareOptions.IgnoreNonSpace

    // Ligature characters and their non-ligature forms compare equal with the IgnoreNonSpace option.
    // Note: prior to .NET 5, ligature characters were equal to their expanded forms by default.
    testStringEquality "straße œuvre cæsar" "strasse oeuvre caesar" "Ligature characters" CompareOptions.IgnoreNonSpace

    0 // return an integer exit code

(*
In .NET 5 and later, the output will be the following:

Case sensitivity:
  When using CompareOptions.None, "ONE two" and "one TWO" are not equal.
  When using CompareOptions.IgnoreCase, "ONE two" and "one TWO" are equal.

Punctuation:
  When using CompareOptions.None, "hello world" and "hello, world!" are not equal.
  When using CompareOptions.IgnoreSymbols, "hello world" and "hello, world!" are equal.

Whitespace and mathematical symbols:
  When using CompareOptions.None, "3 + 5 = 8" and "358" are not equal.
  When using CompareOptions.IgnoreSymbols, "3 + 5 = 8" and "358" are equal.

Currency symbols, decimals and thousands separators:
  When using CompareOptions.None, "Total $15,000" and "Total: £150.00" are not equal.
  When using CompareOptions.IgnoreSymbols, "Total $15,000" and "Total: £150.00" are equal.

Half width and full width characters:
  When using CompareOptions.None, "ａｂｃ，－" and "abc,-" are not equal.
  When using CompareOptions.IgnoreWidth, "ａｂｃ，－" and "abc,-" are equal.

Hiragana and Katakana strings:
  When using CompareOptions.None, "ありがとう" and "アリガトウ" are not equal.
  When using CompareOptions.IgnoreKanaType, "ありがとう" and "アリガトウ" are equal.

Diacritical marks:
  When using CompareOptions.None, "café" and "cafe" are not equal.
  When using CompareOptions.IgnoreNonSpace, "café" and "cafe" are equal.

Ligature characters:
  When using CompareOptions.None, "straße œuvre cæsar" and "strasse oeuvre caesar" are not equal.
  When using CompareOptions.IgnoreNonSpace, "straße œuvre cæsar" and "strasse oeuvre caesar" are equal.


Note: when using .NET versions prior to .NET 5, ligature characters compare as equal to their
non-ligature counterparts by default, so the last test will output as follows:

Ligature characters:
  When using CompareOptions.None, "straße œuvre cæsar" and "strasse oeuvre caesar" are equal.
  When using CompareOptions.IgnoreNonSpace, "straße œuvre cæsar" and "strasse oeuvre caesar" are equal.
*)

Imports System
Imports System.Globalization

Module CompareOptionsExample
    Sub Main()
        ' Uppercase and lowercase characters are equivalent (according to the culture rules)
        ' when IgnoreCase is used.
        TestStringEquality("ONE two", "one TWO", "Case sensitivity", CompareOptions.IgnoreCase)

        ' Punctuation is ignored with the IgnoreSymbols option.
        TestStringEquality("hello world", "hello, world!", "Punctuation", CompareOptions.IgnoreSymbols)

        ' Whitespace and mathematical symbols are also ignored with IgnoreSymbols.
        TestStringEquality("3 + 5 = 8", "358", "Whitespace and mathematical symbols", CompareOptions.IgnoreSymbols)

        ' Caution: currency symbols and thousands separators are ignored with IgnoreSymbols.
        ' Parse strings containing numbers/currency and compare them numerically instead.
        TestStringEquality("Total $15,000", "Total: £150.00", "Currency symbols, decimals and thousands separators", CompareOptions.IgnoreSymbols)

        ' Full width characters are common in East Asian languages. Use the IgnoreWidth
        ' option to treat full- and half-width characters as equal.
        TestStringEquality("ａｂｃ，－", "abc,-", "Half width and full width characters", CompareOptions.IgnoreWidth)

        ' The same string in Hiragana and Katakana is equal when IgnoreKanaType is used.
        TestStringEquality("ありがとう", "アリガトウ", "Hiragana and Katakana strings", CompareOptions.IgnoreKanaType)

        ' When comparing with the IgnoreNonSpace option, characters like diacritical marks are ignored.
        TestStringEquality("café", "cafe", "Diacritical marks", CompareOptions.IgnoreNonSpace)

        ' Ligature characters and their non-ligature forms compare equal with the IgnoreNonSpace option.
        ' Note: prior to .NET 5, ligature characters were equal to their expanded forms by default.
        TestStringEquality("straße œuvre cæsar", "strasse oeuvre caesar", "Ligature characters", CompareOptions.IgnoreNonSpace)
    End Sub

    Private Sub TestStringEquality(str1 As String, str2 As String, description As String, options As CompareOptions)
        Console.WriteLine(Environment.NewLine & description & ":")
        ' First test with the default CompareOptions then with the provided options
        TestStringEqualityWithOptions(str1, str2, CompareOptions.None)
        TestStringEqualityWithOptions(str1, str2, options)
    End Sub

    Private Sub TestStringEqualityWithOptions(str1 As String, str2 As String, options As CompareOptions)
        Console.Write($"  When using CompareOptions.{options}, ""{str1}"" and ""{str2}"" are ")
        If String.Compare(str1, str2, CultureInfo.InvariantCulture, options) <> 0 Then
            Console.Write("not ")
        End If
        Console.WriteLine("equal.")
    End Sub
End Module

' In .NET 5 and later, the output is the following:
'
'Case sensitivity :
'  When using CompareOptions.None, "ONE two" and "one TWO" are not equal.
'  When using CompareOptions.IgnoreCase, "ONE two" and "one TWO" are equal.
'
'Punctuation:
'  When using CompareOptions.None, "hello world" and "hello, world!" are not equal.
'  When using CompareOptions.IgnoreSymbols, "hello world" and "hello, world!" are equal.
'
'Whitespace And mathematical symbols:
'  When using CompareOptions.None, "3 + 5 = 8" and "358" are not equal.
'  When using CompareOptions.IgnoreSymbols, "3 + 5 = 8" and "358" are equal.
'
'Currency symbols, decimals And thousands separators:
'  When using CompareOptions.None, "Total $15,000" and "Total: £150.00" are not equal.
'  When using CompareOptions.IgnoreSymbols, "Total $15,000" and "Total: £150.00" are equal.
'
'Half width And full width characters:
'  When using CompareOptions.None, "ａｂｃ，－" and "abc,-" are not equal.
'  When using CompareOptions.IgnoreWidth, "ａｂｃ，－" and "abc,-" are equal.
'
'Hiragana And Katakana strings:
'  When using CompareOptions.None, "ありがとう" and "アリガトウ" are not equal.
'  When using CompareOptions.IgnoreKanaType, "ありがとう" and "アリガトウ" are equal.
'
'Diacritical marks :
'  When using CompareOptions.None, "café" and "cafe" are not equal.
'  When using CompareOptions.IgnoreNonSpace, "café" and "cafe" are equal.
'
'Ligature characters :
'  When using CompareOptions.None, "straße œuvre cæsar" and "strasse oeuvre caesar" are not equal.
'  When using CompareOptions.IgnoreNonSpace, "straße œuvre cæsar" and "strasse oeuvre caesar" are equal.
'
' Note: when using .NET versions prior to .NET 5, ligature characters compare as equal to their
' non-ligature counterparts by default, so the last test will output as follows:
'
'Ligature characters :
'  When using CompareOptions.None, "straße œuvre cæsar" and "strasse oeuvre caesar" are equal.
'  When using CompareOptions.IgnoreNonSpace, "straße œuvre cæsar" and "strasse oeuvre caesar" are equal.

O exemplo de código a seguir mostra como a classificação com StringSort difere da classificação sem StringSort.

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

public class StringSort
{
    public static void Run()
    {
        var wordList = new List<string>
        {
            "cant", "bill's", "coop", "cannot", "billet", "can't", "con", "bills", "co-op"
        };

        Console.WriteLine("Before sorting:");
        foreach (string word in wordList)
        {
            Console.WriteLine(word);
        }

        Console.WriteLine(Environment.NewLine + "After sorting with CompareOptions.None:");
        SortAndDisplay(wordList, CompareOptions.None);

        Console.WriteLine(Environment.NewLine + "After sorting with CompareOptions.StringSort:");
        SortAndDisplay(wordList, CompareOptions.StringSort);
    }

    // Sort the list of words with the supplied CompareOptions.
    private static void SortAndDisplay(List<string> unsorted, CompareOptions options)
    {
        // Create a copy of the original list to sort.
        var words = new List<string>(unsorted);
        // Define the CompareInfo to use to compare strings.
        CompareInfo comparer = CultureInfo.InvariantCulture.CompareInfo;

        // Sort the copy with the supplied CompareOptions then display.
        words.Sort((str1, str2) => comparer.Compare(str1, str2, options));
        foreach (string word in words)
        {
            Console.WriteLine(word);
        }
    }
}

/*
CompareOptions.None and CompareOptions.StringSort provide identical ordering by default
in .NET 5 and later. But in prior versions, the output is the following:

Before sorting:
cant
bill's
coop
cannot
billet
can't
con
bills
co-op

After sorting with CompareOptions.None:
billet
bills
bill's
cannot
cant
can't
con
coop
co-op

After sorting with CompareOptions.StringSort:
bill's
billet
bills
can't
cannot
cant
co-op
con
coop
*/

module compareoptions_stringsort

open System
open System.Collections.Generic
open System.Globalization

let sortAndDisplay (unsorted: List<string>) (options: CompareOptions) =
    let words = new List<string>(unsorted)
    let comparer = CultureInfo.InvariantCulture.CompareInfo
    words.Sort((fun str1 str2 -> comparer.Compare(str1, str2, options)))
    for word in words do
        printfn "%s" word

[<EntryPoint>]
let main argv =
    let wordList = new List<string>(
        ["cant"; "bill's"; "coop"; "cannot"; "billet"; "can't"; "con"; "bills"; "co-op"])

    printfn "Before sorting:"
    for word in wordList do
        printfn "%s" word

    printfn "\nAfter sorting with CompareOptions.None:"
    sortAndDisplay wordList CompareOptions.None

    printfn "\nAfter sorting with CompareOptions.StringSort:"
    sortAndDisplay wordList CompareOptions.StringSort

    0 // return an integer exit code

(*
CompareOptions.None and CompareOptions.StringSort provide identical ordering by default
in .NET 5 and later, but in prior versions, the output will be the following:

Before sorting:
cant
bill's
coop
cannot
billet
can't
con
bills
co-op

After sorting with CompareOptions.None:
billet
bills
bill's
cannot
cant
can't
con
coop
co-op

After sorting with CompareOptions.StringSort:
bill's
billet
bills
can't
cannot
cant
co-op
con
coop
*)

Imports System
Imports System.Collections.Generic
Imports System.Globalization

Public Class StringSort
    Public Shared Sub Main()
        Dim wordList As New List(Of String) From {
            "cant", "bill's", "coop", "cannot", "billet", "can't", "con", "bills", "co-op"
        }

        Console.WriteLine("Before sorting:")
        For Each word In wordList
            Console.WriteLine(word)
        Next

        Console.WriteLine(Environment.NewLine & "After sorting with CompareOptions.None:")
        SortAndDisplay(wordList, CompareOptions.None)

        Console.WriteLine(Environment.NewLine & "After sorting with CompareOptions.StringSort:")
        SortAndDisplay(wordList, CompareOptions.StringSort)
    End Sub

    ' Sort the list of words with the supplied CompareOptions.
    Private Shared Sub SortAndDisplay(unsorted As List(Of String), options As CompareOptions)
        ' Create a copy of the original list to sort.
        Dim words As New List(Of String)(unsorted)

        ' Define the CompareInfo to use to compare strings.
        Dim comparer As CompareInfo = CultureInfo.InvariantCulture.CompareInfo

        ' Sort the copy with the supplied CompareOptions then display.
        words.Sort(Function(str1, str2) comparer.Compare(str1, str2, options))

        For Each word In words
            Console.WriteLine(word)
        Next
    End Sub
End Class

' CompareOptions.None and CompareOptions.StringSort provide identical ordering by default
' in .NET 5 And later, but in prior versions, the output is the following:
'
'Before sorting
'cant
'bill's
'coop
'cannot
'billet
'can't
'con
'bills
'co-op

'After sorting with CompareOptions.None
'billet
'bills
'bill's
'cannot
'cant
'can't
'con
'coop
'co-op

'After sorting with CompareOptions.StringSort
'bill's
'billet
'bills
'can't
'cannot
'cant
'co-op
'con
'coop

Comentários

No .NET 5 e posterior, a biblioteca de UTI multiplataforma (Componentes Internacionais para Unicode) é usada para processamento de cadeia de caracteres. A biblioteca de UTI traz as seguintes alterações no comportamento de comparação de cadeias de caracteres:

  • A opção None padrão é equivalente à opção StringSort . A funcionalidade anterior de None, em que a ponderação igual foi dada a caracteres alfanuméricos e não numéricos, não está mais disponível.
  • Ligaturas (caracteres combinados como "æ" e "œ") são vistas como distintas de suas formas expandidas ("ae", "oe") em comparações de cadeia de caracteres por padrão. Para tratar ligaturas e seus formulários expandidos como equivalentes, use a opção IgnoreNonSpace .

Para obter mais informações sobre a alteração, incluindo como restaurar o manipulador Unicode anterior, consulte .NET globalização e UTI.

Para obter mais informações sobre essa API, consulte comentários de API Suplementar para CompareOptions.

Aplica-se a

Confira também