CompareOptions Enumeration

Definition

Namespace:

System.Globalization

Assembly:

mscorlib.dll

Definiert die Zeichenfolgenvergleichsoptionen, die mit CompareInfoverwendet werden sollen.

Diese Enumeration unterstützt eine bitweise Kombination ihrer Memberwerte.

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

Vererbung

Object

ValueType

Enum

CompareOptions

Attribute

FlagsAttribute SerializableAttribute ComVisibleAttribute

Felder

Name	Wert	Beschreibung
None	0	Ein Zeichenfolgenvergleich mit den Standardoptionseinstellungen.
IgnoreCase	1	Ein Zeichenfolgenvergleich, der Groß-/Kleinschreibungsunterschiede ignoriert.
IgnoreNonSpace	2	Ein Zeichenfolgenvergleich, der nicht zeichenfolgengleiche Kombinationszeichen wie diakritische Zeichen ignoriert. Zeichen ohne Abstand ändern Basiszeichen, ohne eigene Leerzeichen einzunehmen. Der Unicode-Standard definiert die Kombination von Zeichen als Zeichen, die mit Basiszeichen kombiniert werden, um ein neues Zeichen zu erzeugen.
IgnoreSymbols	4	Ein Zeichenfolgenvergleich, der Symbole ignoriert, einschließlich Leerzeichen, Satzzeichen, Währungssymbole, Prozentzeichen, mathematische Symbole, kaufmännisches Und-Zeichen und ähnliche Zeichen.
IgnoreKanaType	8	Ein Zeichenfolgenvergleich, der den Kana-Typ ignoriert. Kana-Typ bezieht sich auf japanische Hiragana- und Katakana-Zeichen, die phonetische Sounds darstellen. Hiragana wird für native japanische Wörter verwendet, während Katakana für Wörter verwendet wird, die aus anderen Sprachen geliehen wurden. Mit dieser Option werden Hiragana- und Katakana-Zeichen, die denselben Sound darstellen, als gleich angesehen.
IgnoreWidth	16	Ein Zeichenfolgenvergleich, der die Zeichenbreite ignoriert. Beispielsweise werden Formen mit voller Breite und halber Breite japanischer Katakana-Zeichen mit dieser Option gleich angesehen.
OrdinalIgnoreCase	268435456	Ein Zeichenfolgenvergleich, der die Groß-/Kleinschreibung ignoriert, führt dann einen Ordinalvergleich aus. Diese Technik entspricht dem Konvertieren der Zeichenfolge in Großbuchstaben mithilfe der invarianten Kultur und anschließendem Durchführen eines Ordinalvergleichs für das Ergebnis. 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	Ein Zeichenfolgenvergleich, der den Zeichenfolgensortierungsalgorithmus verwendet, wobei nichtalphanumerische Symbole (z. B. Bindestriche und Apostrophe) vor alphanumerischen Zeichen sortiert werden.
Ordinal	1073741824	Ein Zeichenfolgenvergleich, der die Unicode UTF-16-codierten Werte der Zeichenfolgen verwendet, und vergleicht sie anhand der Codeeinheit. Dies führt zu einem schnellen, kulturunempfindlichen Vergleich, bei dem Zeichenfolgen nur basierend auf ihren Binärwerten sortiert werden. Diese Option kann nicht mit anderen CompareOptions Werten kombiniert werden und muss allein verwendet werden.

Beispiele

Das folgende Codebeispiel zeigt, wie sich die einzelnen CompareOptions Werte auf Zeichenfolgenvergleiche auswirken.

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.

Das folgende Codebeispiel zeigt, wie sich die Sortierung von StringSort der Sortierung ohne StringSort unterscheidet.

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

Hinweise

In .NET 5 und höher wird die plattformübergreifende ICU -Bibliothek (Internationale Komponenten für Unicode) für die Zeichenfolgenverarbeitung verwendet. Die ICU-Bibliothek bringt die folgenden Änderungen an dem Verhalten des Zeichenfolgenvergleichs:

• Die Standardoption None entspricht der StringSort Option. Die vorherige Funktion von None, wobei die gleiche Gewichtung alphanumerischen und nichtalphanumerischen Zeichen zugewiesen wurde, ist nicht mehr verfügbar.
• Ligaturen (kombinierte Zeichen wie "æ" und "œ") werden in Zeichenfolgenvergleichen standardmäßig als von ihren erweiterten Formen ("ae", "oe") unterschieden. Verwenden Sie die IgnoreNonSpace Option, um Ligaturen und ihre erweiterten Formen als gleichwertig zu behandeln.

Weitere Informationen zur Änderung, einschließlich der Wiederherstellung des vorherigen Unicode-Handlers, finden Sie unter .NET Globalisierung und ICU.

Weitere Informationen zu dieser API finden Sie in den ergänzenden API-Hinweisen für CompareOptions.

Weitere Informationen

• Basic String Operations in .NET