CompareOptions Enumeração

Definição

Espaço de Nomes:

System.Globalization

Assemblagem:

mscorlib.dll

Define as opções de comparação de cadeias a usar com CompareInfo.

Esta enumeração suporta uma combinação bit-a-bit dos respetivos valores membro.

public enum class CompareOptions

[System.Flags]
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public enum 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

Name	Valor	Description
None	0	Uma comparação de cadeias com as definições de opções por defeito.
IgnoreCase	1	Uma comparação de cadeias que ignora as diferenças de casos.
IgnoreNonSpace	2	Uma comparação de cadeias que ignora caracteres combinadores sem espaçamento, como diacríticos. Caracteres sem espaçamento modificam os caracteres base sem ocupar o seu próprio espaço. O Padrão Unicode define a combinação de caracteres como caracteres que são combinados com caracteres base para produzir um novo carácter.
IgnoreSymbols	4	Uma comparação de cadeias que ignora símbolos, incluindo espaços em branco, pontuação, símbolos de moeda, o sinal de porcentagem, símbolos matemáticos, o e caracteres semelhantes.
IgnoreKanaType	8	Uma comparação de cordas que ignora o tipo kana. O tipo Kana refere-se aos caracteres japoneses hiragana e katakana, que representam sons fonéticos. Hiragana é usado para palavras japonesas nativas, enquanto katakana é usado para palavras emprestadas de outras línguas. Com esta opção, caracteres hiragana e katakana que representam o mesmo som são considerados iguais.
IgnoreWidth	16	Uma comparação de cadeias que ignora a largura dos caracteres. Por exemplo, formas de largura total e meia largura dos caracteres katakana japoneses são consideradas iguais com esta opção.
OrdinalIgnoreCase	268435456	Uma comparação de cadeias que ignora o caso e depois realiza uma comparação ordinal. Esta técnica é equivalente a converter a corda para maiúsculas usando a cultura invariante e depois realizar uma comparação ordinal do 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 cadeias que utiliza o algoritmo de ordenação de cadeias, onde símbolos não alfanuméricos (como hífens e apóstrofos) são ordenados antes dos caracteres alfanuméricos.
Ordinal	1073741824	Uma comparação de strings que utiliza os valores codificados Unicode UTF-16 das strings, comparando-as unidade por unidade de código. Isto resulta numa comparação rápida e insensível à cultura, onde as cadeias são ordenadas apenas com base nos seus valores binários. Esta opção não pode ser combinada com outros CompareOptions valores e deve ser usada isoladamente.

Exemplos

O seguinte exemplo de código mostra como cada um dos CompareOptions valores afeta as comparações de cadeias.

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 seguinte mostra como ordenar com StringSort difere de ordenar 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

Observações

No .NET 5 e posteriores, a biblioteca multiplataforma ICU (International Components for Unicode) é usada para processamento de cadeias. A biblioteca da UCI traz as seguintes alterações ao comportamento de comparação de strings:

• A opção None padrão é equivalente à StringSort opção. A funcionalidade anterior de None, onde era atribuída a igual ponderação a caracteres alfanuméricos e não alfanuméricos, já não está disponível.
• As ligaduras (caracteres combinados como "æ" e "œ") são vistas como distintas das suas formas expandidas ("ae", "oe") nas comparações de sequências por defeito. Para tratar as ligaduras e as suas formas expandidas como equivalentes, use a IgnoreNonSpace opção.

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

Para mais informações sobre esta API, consulte Observações Suplementares da API para CompareOptions.

Ver também

• Operações Básicas de Cadeias em .NET