CompareOptions Enum

Definisi

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

Warisan

Object

ValueType

Enum

CompareOptions

Atribut

FlagsAttribute SerializableAttribute ComVisibleAttribute

Bidang

    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.

Contoh

Contoh kode berikut menunjukkan bagaimana masing-masing CompareOptions nilai memengaruhi perbandingan string.

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.

Contoh kode berikut menunjukkan bagaimana pengurutan dengan StringSort berbeda dari pengurutan tanpa 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

Keterangan

Dalam .NET 5 dan yang lebih baru, pustaka ICU lintas platform (Komponen Internasional untuk Unicode) digunakan untuk pemrosesan string. Pustaka ICU membawa perubahan berikut pada perilaku perbandingan string:

• Opsi None default setara dengan StringSort opsi . Fungsionalitas sebelumnya dari None, di mana pembobotan yang sama diberikan kepada karakter alfanumerik dan non-alfanumerik, tidak lagi tersedia.
• Ligatur (karakter gabungan seperti "æ" dan "œ") dipandang berbeda dari bentuk yang diperluas ("ae", "oe") dalam perbandingan string secara default. Untuk memperlakukan ligatur dan bentuknya yang diperluas setara, gunakan IgnoreNonSpace opsi .

Untuk informasi selengkapnya tentang perubahan, termasuk cara memulihkan handler Unicode sebelumnya, lihat .NET globalisasi dan ICU.

Opsi CompareOptions menunjukkan sensitivitas atau kebutuhan kasus untuk mengabaikan jenis karakter.

.NET menggunakan tiga cara pengurutan yang berbeda: pengurutan kata, pengurutan string, dan pengurutan ordinal. Pengurutan kata melakukan perbandingan string yang sensitif terhadap budaya. Karakter non-alfanumerik tertentu mungkin diberikan bobot khusus. Misalnya, tanda hubung ("-") mungkin memiliki nilai yang sangat kecil yang ditetapkan untuk itu sehingga "coop" dan "co-op" muncul berdampingan dalam daftar yang diurutkan. Pengurutan string mirip dengan pengurutan kata, kecuali bahwa tidak ada kasus khusus. Oleh karena itu, semua simbol non-alfanumerik datang sebelum semua karakter alfanumerik. Pengurutan ordinal membandingkan string berdasarkan nilai Unicode dari setiap elemen string. Untuk kumpulan file teks yang dapat diunduh yang berisi informasi tentang bobot karakter yang digunakan dalam operasi pengurutan dan perbandingan untuk sistem operasi Windows, lihat Mengurutkan Tabel Berat. Untuk tabel bobot pengurutan pada Linux dan macOS, lihat Tabel Elemen Kolasi Unicode Default. Versi spesifik tabel berat sortir di Linux dan macOS bergantung pada versi pustaka Komponen Internasional Unicode yang diinstal pada sistem. Untuk informasi tentang versi ICU dan versi Unicode yang mereka terapkan, lihat Mengunduh ICU.

Nilai StringSort hanya dapat digunakan dengan CompareInfo.Compare dan CompareInfo.GetSortKey. ArgumentExceptiondilemparkan jika nilai StringSort digunakan dengan CompareInfo.IsPrefix, , CompareInfo.IsSuffixCompareInfo.IndexOf, atau CompareInfo.LastIndexOf.

Pengurutan sensitif budaya

Lihat juga

• Operasi String Basic di .NET