String.Compare Metódus

Definíció

Névtér:: System

Szerelvények:: netstandard.dll, System.Runtime.dll

Szerelvény:: System.Runtime.dll

Szerelvény:: mscorlib.dll

Szerelvény:: netstandard.dll

Szerelvények:: mscorlib.dll, System.Runtime.dll

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Összehasonlít két megadott String objektumot, és egy egész számot ad vissza, amely a rendezési sorrendben lévő relatív pozíciójukat jelzi.

Túlterhelések

Name	Description
Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)	Két megadott String objektum részszűrését hasonlítja össze a megadott összehasonlítási lehetőségek és kultúraspecifikus információk használatával az összehasonlítás befolyásolása érdekében, és egy egész számot ad vissza, amely a rendezési sorrendben jelzi a két alsztring egymáshoz való viszonyát.
Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)	Két megadott String objektum részsztringjeinek összehasonlítása, figyelmen kívül hagyva vagy tiszteletben tartva az esetüket, valamint kultúraspecifikus információk használata az összehasonlítás befolyásolására, és egy egész számot ad vissza, amely a rendezési sorrendben lévő relatív pozíciójukat jelzi.
Compare(String, Int32, String, Int32, Int32, StringComparison)	Két megadott String objektum részszűrését hasonlítja össze a megadott szabályok használatával, és egy egész számot ad vissza, amely a rendezési sorrendben lévő relatív pozíciójukat jelzi.
Compare(String, Int32, String, Int32, Int32, Boolean)	Két megadott String objektum részszűrését hasonlítja össze, figyelmen kívül hagyva vagy tiszteletben tartva az esetüket, és egy egész számot ad vissza, amely a rendezési sorrendben lévő relatív pozíciójukat jelzi.
Compare(String, Int32, String, Int32, Int32)	Két megadott String objektum részszűrését hasonlítja össze, és egy egész számot ad vissza, amely a rendezési sorrendben lévő relatív pozíciójukat jelzi.
Compare(String, String, CultureInfo, CompareOptions)	Összehasonlít két megadott String objektumot a megadott összehasonlítási lehetőségek és kultúraspecifikus információk használatával az összehasonlítás befolyásolásához, és egy egész számot ad vissza, amely a rendezési sorrendben jelzi a két sztring egymáshoz való viszonyát.
Compare(String, String, Boolean, CultureInfo)	Összehasonlít két megadott String objektumot, figyelmen kívül hagyva vagy tiszteletben tartva az esetüket, és kultúraspecifikus információkat használ az összehasonlítás befolyásolására, és egy egész számot ad vissza, amely a rendezési sorrendben elfoglalt relatív pozíciójukat jelzi.
Compare(String, String, StringComparison)	Két megadott String objektumot hasonlít össze a megadott szabályokkal, és egy egész számot ad vissza, amely a rendezési sorrendben lévő relatív pozíciójukat jelzi.
Compare(String, String, Boolean)	Összehasonlít két megadott String objektumot, figyelmen kívül hagyva vagy tiszteletben tartva az esetüket, és egy egész számot ad vissza, amely a rendezési sorrendben lévő relatív pozíciójukat jelzi.
Compare(String, String)	Összehasonlít két megadott String objektumot, és egy egész számot ad vissza, amely a rendezési sorrendben lévő relatív pozíciójukat jelzi.

Megjegyzések

A metódus minden túlterhelése Compare egy 32 bites aláírt egész számot ad vissza, amely a két összehasonlítás közötti lexikális kapcsolatot jelzi.

Érték	Condition
Nullánál kisebb	Az első részszűrés a rendezési sorrend második alsztringje előtt van.
Nulla	Az alsztringek a rendezési sorrendben ugyanabban a pozícióban fordulnak elő, vagy `length` nulla.
Nullánál nagyobb	Az első részstring a rendezési sorrend második részszúrását követi.

Warning

Amikor lehetséges, a paramétert tartalmazó Compare metódus túlterhelését StringComparison kell meghívnia. További információ: Ajánlott eljárások sztringek használatához.

Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Két megadott String objektum részszűrését hasonlítja össze a megadott összehasonlítási lehetőségek és kultúraspecifikus információk használatával az összehasonlítás befolyásolása érdekében, és egy egész számot ad vissza, amely a rendezési sorrendben jelzi a két alsztring egymáshoz való viszonyát.

public:
 static int Compare(System::String ^ strA, int indexA, System::String ^ strB, int indexB, int length, System::Globalization::CultureInfo ^ culture, System::Globalization::CompareOptions options);

public static int Compare(string? strA, int indexA, string? strB, int indexB, int length, System.Globalization.CultureInfo? culture, System.Globalization.CompareOptions options);

public static int Compare(string strA, int indexA, string strB, int indexB, int length, System.Globalization.CultureInfo culture, System.Globalization.CompareOptions options);

static member Compare : string * int * string * int * int * System.Globalization.CultureInfo * System.Globalization.CompareOptions -> int

Public Shared Function Compare (strA As String, indexA As Integer, strB As String, indexB As Integer, length As Integer, culture As CultureInfo, options As CompareOptions) As Integer

Paraméterek

strA: String

Az összehasonlításban elsőként használandó sztring.

indexA: Int32

A részszúrás kezdő pozíciója a következőn belül strA: .

strB: String

Az összehasonlításban használt második sztring.

indexB: Int32

A részszúrás kezdő pozíciója a következőn belül strB: .

length: Int32

Az összehasonlítandó alsztringek karaktereinek maximális száma.

culture: CultureInfo

Egy objektum, amely kultúraspecifikus összehasonlító információkat szolgáltat. Ha culture van null, a jelenlegi kultúrát használják.

options: CompareOptions

Az összehasonlítás során használandó beállítások (például a kis- és nagybetűk figyelmen kívül hagyása).

Válaszok

Int32

Egész szám, amely a két részstring közötti lexikális kapcsolatot jelzi az alábbi táblázatban látható módon.

Érték	Feltétel
Nullánál kisebb	Az alsztring `strA` a rendezési sorrendben `strB` lévő részszűrést megelőzi.
Nulla	Az alsztringek a rendezési sorrendben ugyanabban a pozícióban fordulnak elő, vagy `length` nulla.
Nullánál nagyobb	Az alászúrás `strA` a rendezési sorrendben `strB` lévő részszúrást követi.

Kivételek

ArgumentException

options nem érték CompareOptions .

ArgumentOutOfRangeException

indexA nagyobb, mint strA.Length.

-vagy-

indexB nagyobb, mint strB.Length.

-vagy-

indexA, indexBvagy length negatív.

-vagy-

strA Vagy strB aznull, és length nagyobb, mint nulla.

Példák

Az alábbi példa két személy vezetékneveinek összehasonlítására használja a Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) metódust. Ezután betűrendben listázza őket.

string name1 = "Jack Smith";
string name2 = "John Doe";

// Get position of character after the space character.
int index1 = name1.IndexOf(" ");
index1 = index1 < 0 ? 0 : ++index1;

int index2 = name2.IndexOf(" ");
index2 = index2 < 0 ? 0 : ++index2;

int length = Math.Max(name1.Length, name2.Length);

Console.WriteLine("Sorted alphabetically by last name:");
if (String.Compare(name1, index1, name2, index2, length,
                   new CultureInfo("en-US"), CompareOptions.IgnoreCase) < 0)
    Console.WriteLine("{0}\n{1}", name1, name2);
else
    Console.WriteLine("{0}\n{1}", name2, name1);

// The example displays the following output:
//       Sorted alphabetically by last name:
//       John Doe
//       Jack Smith

open System
open System.Globalization

let name1 = "Jack Smith"
let name2 = "John Doe"

// Get position of character after the space character.
let index1 =
    let i = name1.IndexOf " "
    if i < 0 then 0 else i + 1

let index2 = 
    let i = name2.IndexOf " "
    if i < 0 then 0 else i + 1

let length = max name1.Length name2.Length

printfn "Sorted alphabetically by last name:"
if String.Compare(name1, index1, name2, index2, length, CultureInfo "en-US", CompareOptions.IgnoreCase) < 0 then
    printfn $"{name1}\n{name2}"
else
    printfn $"{name2}\n{name1}"

// The example displays the following output:
//       Sorted alphabetically by last name:
//       John Doe
//       Jack Smith

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim name1 As String = "Jack Smith"
      Dim name2 = "John Doe"
      
      ' Get position of space character.
      Dim index1 As Integer = name1.IndexOf(" ")
      index1 = CInt(IIf(index1 < 0, 0, index1 - 1))
      
      Dim index2 As Integer = name2.IndexOf(" ")
      index1 = CInt(IIf(index1 < 0, 0, index1 - 1))
      
      Dim length As Integer = Math.Max(name1.Length, name2.Length)
      
      Console.WriteLIne("Sorted alphabetically by last name:")
      If String.Compare(name1, index1, name2, index2, length, _
                        New CultureInfo("en-US"), CompareOptions.IgnoreCase) < 0 Then
         Console.WriteLine("{0}{1}{2}", name1, vbCrLf, name2)
      Else
         Console.WriteLine("{0}{1}{2}", name2, vbCrLf, name1)
      End If
   End Sub
End Module
' The example displays the following output;
'       Sorted alphabetically by last name:
'       John Doe
'       Jack Smith

Megjegyzések

A pozícióban strA és a pozícióban indexAstrBindexBvaló kezdés összehasonlításához használt részsztringek . Az első részszúrás hossza a mínusz strA.indexA A második részszűrés hossza a mínusz strBhossza indexB .

Az összehasonlítandó karakterek száma a két részsztring hosszának kisebb része, és lengtha . A indexA, indexBés length a paraméterek nem lehetnek nemegatívak.

Az összehasonlítás a paraméter használatával szerzi be a culture kultúraspecifikus információkat, például a casing szabályokat és az egyes karakterek betűrendjét. Egy adott kultúra például megadhatja, hogy a karakterek bizonyos kombinációi egyetlen karakterként legyenek kezelve, hogy a kis- és nagybetűket egy adott módon hasonlítsa össze, vagy hogy egy karakter rendezési sorrendje az azt megelőző vagy követő karakterektől függ.

Figyelmeztetés

A Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) metódus elsősorban rendezési vagy betűrendezési műveletekhez használható. Nem használható, ha a metódushívás elsődleges célja annak megállapítása, hogy két részszűkítés egyenértékű-e (vagyis amikor a metódushívás célja a nulla visszatérési érték tesztelése). Annak megállapításához, hogy két sztring egyenértékű-e, hívja meg a metódust Equals .

Az egyik vagy mindkettő strA , és strB lehet null. Definíció szerint minden sztring , beleértve a String.Emptynullhivatkozásnál nagyobbat is, és két nullhivatkozás egyenlő egymással.

Az összehasonlítást tovább lehet adni a options paraméterrel, amely az System.Globalization.CompareOptions enumerálás egy vagy több tagját tartalmazza. Mivel azonban ennek a módszernek a célja a kultúraérzékeny sztringek összehasonlítása, az CompareOptions.Ordinal értékeknek CompareOptions.OrdinalIgnoreCase nincs hatása.

Az összehasonlítás akkor fejeződik be, ha egy egyenlőtlenséget fedeznek fel, vagy mindkét részszűrést összehasonlítják. Ha azonban a két sztring az egyik sztring végével egyenlő, a másik sztringben pedig maradnak karakterek, akkor a fennmaradó karakterekkel rendelkező sztring nagyobbnak minősül. A visszatérési érték az utolsó elvégzett összehasonlítás eredménye.

Megjegyzések a hívókhoz

A karakterkészletek figyelmen kívül hagyható karaktereket tartalmaznak. A Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) metódus nem veszi figyelembe ezeket a karaktereket, ha nyelvi vagy kulturális szempontból érzékeny összehasonlítást végez. Ha az összehasonlításban figyelmen kívül hagyható karaktereket szeretne felismerni, adja meg a paraméter értékét Ordinal vagy OrdinalIgnoreCase értékét options .

Lásd még

Equals

A következőre érvényes:

Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Két megadott String objektum részsztringjeinek összehasonlítása, figyelmen kívül hagyva vagy tiszteletben tartva az esetüket, valamint kultúraspecifikus információk használata az összehasonlítás befolyásolására, és egy egész számot ad vissza, amely a rendezési sorrendben lévő relatív pozíciójukat jelzi.

public:
 static int Compare(System::String ^ strA, int indexA, System::String ^ strB, int indexB, int length, bool ignoreCase, System::Globalization::CultureInfo ^ culture);

public static int Compare(string? strA, int indexA, string? strB, int indexB, int length, bool ignoreCase, System.Globalization.CultureInfo? culture);

public static int Compare(string strA, int indexA, string strB, int indexB, int length, bool ignoreCase, System.Globalization.CultureInfo culture);

static member Compare : string * int * string * int * int * bool * System.Globalization.CultureInfo -> int

Public Shared Function Compare (strA As String, indexA As Integer, strB As String, indexB As Integer, length As Integer, ignoreCase As Boolean, culture As CultureInfo) As Integer

Paraméterek

strA: String

Az összehasonlításban elsőként használandó sztring.

indexA: Int32

Az alsztring pozíciója a következőn belül strA: .

strB: String

Az összehasonlításban használt második sztring.

indexB: Int32

Az alsztring pozíciója a következőn belül strB: .

length: Int32

Az összehasonlítandó alsztringek karaktereinek maximális száma.

ignoreCase: Boolean

truea kis- és nagybetűk figyelmen kívül hagyása az összehasonlítás során; egyéb esetben. false

culture: CultureInfo

Egy objektum, amely kultúraspecifikus összehasonlító információkat szolgáltat. Ha culture van null, a jelenlegi kultúrát használják.

Válaszok

Int32

Egy egész szám, amely a két összehasonlítás lexikális kapcsolatát jelzi.

Érték	Feltétel
Nullánál kisebb	Az alsztring `strA` a rendezési sorrendben `strB` lévő részszűrést megelőzi.
Nulla	Az alsztringek a rendezési sorrendben ugyanabban a pozícióban fordulnak elő, vagy `length` nulla.
Nullánál nagyobb	Az alászúrás `strA` a rendezési sorrendben `strB` lévő részszúrást követi.

Kivételek

ArgumentOutOfRangeException

indexA nagyobb, mint strA.Length.

-vagy-

indexB nagyobb, mint strB.Length.

-vagy-

indexA, indexBvagy length negatív.

-vagy-

strA Vagy strB aznull, és length nagyobb, mint nulla.

Példák

Az alábbi példa két, különböző kultúrákat használó alsztringet hasonlít össze, és figyelmen kívül hagyja az alsztringek esetét. A kultúra megválasztása befolyásolja az "I" betű összehasonlítását.

// Sample for String.Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)
using System;
using System.Globalization;

class Sample5
{
    public static void Main()
    {
        //                 0123456
        String str1 = "MACHINE";
        String str2 = "machine";
        String str;
        int result;

        Console.WriteLine();
        Console.WriteLine("str1 = '{0}', str2 = '{1}'", str1, str2);
        Console.WriteLine("Ignore case, Turkish culture:");
        result = String.Compare(str1, 4, str2, 4, 2, true, new CultureInfo("tr-TR"));
        str = ((result < 0) ? "less than" : ((result > 0) ? "greater than" : "equal to"));
        Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(4, 2), str1);
        Console.Write("{0} ", str);
        Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(4, 2), str2);

        Console.WriteLine();
        Console.WriteLine("Ignore case, invariant culture:");
        result = String.Compare(str1, 4, str2, 4, 2, true, CultureInfo.InvariantCulture);
        str = ((result < 0) ? "less than" : ((result > 0) ? "greater than" : "equal to"));
        Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(4, 2), str1);
        Console.Write("{0} ", str);
        Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(4, 2), str2);
    }
}
/*
This example produces the following results:

str1 = 'MACHINE', str2 = 'machine'
Ignore case, Turkish culture:
Substring 'IN' in 'MACHINE' is less than substring 'in' in 'machine'.

Ignore case, invariant culture:
Substring 'IN' in 'MACHINE' is equal to substring 'in' in 'machine'.
*/

// Sample for String.Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)
open System
open System.Globalization

//                 0123456
let str1 = "MACHINE"
let str2 = "machine"

printfn $"\nstr1 = '{str1}', str2 = '{str2}'"
printfn "Ignore case, Turkish culture:"
let result = String.Compare(str1, 4, str2, 4, 2, true, CultureInfo "tr-TR")
let str = if result < 0 then "less than" elif result > 0 then "greater than" else "equal to"
printf $"Substring '{str1.Substring(4, 2)}' in '{str1}' is "
printf $"{str} "
printfn $"substring '{str2.Substring(4, 2)}' in '{str2}'."

printfn "\nIgnore case, invariant culture:"
let result2 = String.Compare(str1, 4, str2, 4, 2, true, CultureInfo.InvariantCulture)
let str3 = if result < 0 then "less than" elif result > 0 then "greater than" else "equal to"
printf $"Substring '{str1.Substring(4, 2)}' in '{str1}' is "
printf $"{str3} "
printfn $"substring '{str2.Substring(4, 2)}' in '{str2}'."

(*
This example produces the following results:

str1 = 'MACHINE', str2 = 'machine'
Ignore case, Turkish culture:
Substring 'IN' in 'MACHINE' is less than substring 'in' in 'machine'.

Ignore case, invariant culture:
Substring 'IN' in 'MACHINE' is equal to substring 'in' in 'machine'.
*)

' Sample for String.Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)
Imports System.Globalization

Class Sample
   
   Public Shared Sub Main()
      '                       0123456
      Dim str1 As [String] = "MACHINE"
      Dim str2 As [String] = "machine"
      Dim str As [String]
      Dim result As Integer
      
      Console.WriteLine()
      Console.WriteLine("str1 = '{0}', str2 = '{1}'", str1, str2)
      Console.WriteLine("Ignore case, Turkish culture:")
      result = [String].Compare(str1, 4, str2, 4, 2, True, New CultureInfo("tr-TR"))
      str = IIf(result < 0, "less than", IIf(result > 0, "greater than", "equal to"))
      Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(4, 2), str1)
      Console.Write("{0} ", str)
      Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(4, 2), str2)
      
      Console.WriteLine()
      Console.WriteLine("Ignore case, invariant culture:")
      result = [String].Compare(str1, 4, str2, 4, 2, True, CultureInfo.InvariantCulture)
      str = IIf(result < 0, "less than", IIf(result > 0, "greater than", "equal to"))
      Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(4, 2), str1)
      Console.Write("{0} ", str)
      Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(4, 2), str2)
   End Sub
End Class
'
'This example produces the following results:
'
'str1 = 'MACHINE', str2 = 'machine'
'Ignore case, Turkish culture:
'Substring 'IN' in 'MACHINE' is less than substring 'in' in 'machine'.
'
'Ignore case, invariant culture:
'Substring 'IN' in 'MACHINE' is equal to substring 'in' in 'machine'.
'

Megjegyzések

A kezdő és a kezdő időpontban összehasonlítandó strAindexAstrBindexBrészszűrések. Mindkettő indexA és indexB nulla alapú; vagyis az első karakter a nulla pozícióban strA van, strB és nem az első pozícióban. Az első részszúrás hossza mínusz strAindexA plusz egy. A második részszúrás hossza mínusz plusz egy.strBindexB

Az összehasonlítandó karakterek száma a két részsztring hosszának kisebb része, és lengtha . A indexA, indexBés length a paraméterek nem lehetnek nemegatívak.

Az összehasonlítás a paraméter használatával szerzi be a culture kultúraspecifikus információkat, például a casing szabályokat és az egyes karakterek betűrendjét. Egy kultúra például megadhatja, hogy a karakterek bizonyos kombinációi egyetlen karakterként legyenek kezelve, vagy a nagybetűket és a kisbetűket egy adott módon hasonlítsa össze, vagy hogy egy karakter rendezési sorrendje az azt megelőző vagy követő karakterektől függ.

Az összehasonlítás szórendezési szabályokkal történik. A szavak, sztringek és sorszámok rendezéséről további információt a következő témakörben talál System.Globalization.CompareOptions: .

Egy vagy mindkét összehasonlítás lehet null. Definíció szerint bármely sztring, beleértve az üres sztringet ("") is, egy null hivatkozásnál nagyobb értéket hasonlít össze; és két nullhivatkozás egyenlő egymással.

Az összehasonlítás akkor fejeződik be, ha egy egyenlőtlenséget fedeznek fel, vagy mindkét részszűrést összehasonlítják. Ha azonban a két sztring egyenlő az egyik sztring végével, a másik sztringben pedig maradnak karakterek, akkor a fennmaradó karakterekkel rendelkező sztring nagyobbnak minősül. A visszatérési érték az utolsó elvégzett összehasonlítás eredménye.

Váratlan eredmények akkor fordulhatnak elő, ha az összehasonlításokat kultúraspecifikus burkolatszabályok befolyásolják. Török nyelven például a következő példa rossz eredményt ad, mert a török fájlrendszer nem használ nyelvi casing szabályokat az "i" betűhöz a "file" fájlban.

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, true) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, true) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, True) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Hasonlítsa össze az elérési utat a "fájl" névvel egy sorszámos összehasonlítással. Ehhez a megfelelő kód a következő:

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Megjegyzések a hívókhoz

A karakterkészletek figyelmen kívül hagyható karaktereket tartalmaznak. A Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) metódus nem veszi figyelembe ezeket a karaktereket, ha nyelvi vagy kulturális szempontból érzékeny összehasonlítást végez. Az összehasonlításban figyelmen kívül hagyható karakterek felismeréséhez hívja meg a metódust Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) , és adja meg a paraméter értékét Ordinal vagy OrdinalIgnoreCase értékét options .

Lásd még

A következőre érvényes:

Compare(String, Int32, String, Int32, Int32, StringComparison)

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Két megadott String objektum részszűrését hasonlítja össze a megadott szabályok használatával, és egy egész számot ad vissza, amely a rendezési sorrendben lévő relatív pozíciójukat jelzi.

public:
 static int Compare(System::String ^ strA, int indexA, System::String ^ strB, int indexB, int length, StringComparison comparisonType);

public static int Compare(string strA, int indexA, string strB, int indexB, int length, StringComparison comparisonType);

public static int Compare(string? strA, int indexA, string? strB, int indexB, int length, StringComparison comparisonType);

static member Compare : string * int * string * int * int * StringComparison -> int

Public Shared Function Compare (strA As String, indexA As Integer, strB As String, indexB As Integer, length As Integer, comparisonType As StringComparison) As Integer

Paraméterek

strA: String

Az összehasonlításban elsőként használandó sztring.

indexA: Int32

Az alsztring pozíciója a következőn belül strA: .

strB: String

Az összehasonlításban használt második sztring.

indexB: Int32

Az alsztring pozíciója a következőn belül strB: .

length: Int32

Az összehasonlítandó alsztringek karaktereinek maximális száma.

comparisonType: StringComparison

Az összehasonlításban használandó szabályokat meghatározó számbavételi értékek egyike.

Válaszok

Int32

Egy 32 bites aláírt egész szám, amely a két összehasonlítás és a két összehasonlítás közötti lexikális kapcsolatot jelzi.

Érték	Feltétel
Nullánál kisebb	Az alsztring `strA` a rendezési sorrendben `strB` lévő részszűrést megelőzi.
Nulla	Az alsztringek a rendezési sorrendben ugyanabban a pozícióban történnek, vagy a `length` paraméter nulla.
Nullánál nagyobb	Az alászúrás `strA` a rendezési sorrendben `strB` lévő részszúrást követi.

Kivételek

ArgumentOutOfRangeException

indexA nagyobb, mint strA.Length.

-vagy-

indexB nagyobb, mint strB.Length.

-vagy-

indexA, indexBvagy length negatív.

-vagy-

indexA Vagy indexB aznull, és length nagyobb, mint nulla.

ArgumentException

comparisonType nem érték StringComparison .

Példák

Az alábbi példa két részstringet hasonlít össze.

String str1 = "machine";
String str2 = "device";
String str;
int result;

Console.WriteLine();
Console.WriteLine("str1 = '{0}', str2 = '{1}'", str1, str2);
result = String.Compare(str1, 2, str2, 0, 2);
str = ((result < 0) ? "less than" : ((result > 0) ? "greater than" : "equal to"));
Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(2, 2), str1);
Console.Write("{0} ", str);
Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(0, 2), str2);

/*
This example produces the following results:

str1 = 'machine', str2 = 'device'
Substring 'ch' in 'machine' is less than substring 'de' in 'device'.
*/

open System

let str1 = "machine"
let str2 = "device"

printfn "\nstr1 = '{str1}', str2 = '{str2}'"

let result = String.Compare(str1, 2, str2, 0, 2)
let str = 
    if result < 0 then "less than" 
    elif result > 0 then "greater than" 
    else "equal to"

printf $"Substring '{str1.Substring(2, 2)}' in '{str1}' is "
printf $"{str} "
printfn $"substring '{str2.Substring(0, 2)}' in '{str2}'."

(*
This example produces the following results:

str1 = 'machine', str2 = 'device'
Substring 'ch' in 'machine' is less than substring 'de' in 'device'.
*)

' Sample for String.Compare(String, Int32, String, Int32, Int32)
Class Sample
   Public Shared Sub Main()
      '                       0123456
      Dim str1 As [String] = "machine"
      Dim str2 As [String] = "device"
      Dim str As [String]
      Dim result As Integer
      
      Console.WriteLine()
      Console.WriteLine("str1 = '{0}', str2 = '{1}'", str1, str2)
      result = [String].Compare(str1, 2, str2, 0, 2)
      str = IIf(result < 0, "less than", IIf(result > 0, "greater than", "equal to"))
      Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(2, 2), str1)
      Console.Write("{0} ", str)
      Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(0, 2), str2)
   End Sub
End Class
'
'This example produces the following results:
'
'str1 = 'machine', str2 = 'device'
'Substring 'ch' in 'machine' is less than substring 'de' in 'device'.
'

Megjegyzések

A kezdő strAindexAstrBindexBés a kezdő időpont összehasonlítása alsztringek. Mindkettő indexA és indexB nulla alapú; vagyis az első karakter a nulla pozícióban strA van, strB és nem az első pozícióban. Az első részszúrás hossza mínusz strAindexA plusz egy. A második részszúrás hossza mínusz plusz egy.strBindexB

Az összehasonlítandó karakterek száma a két részsztring hosszának kisebb része, és lengtha . A indexA, indexBés length a paraméterek nem lehetnek nemegatívak.

A comparisonType paraméter azt jelzi, hogy az összehasonlításnak az aktuális vagy az invariáns kultúrát kell-e használnia, tiszteletben kell-e tartania vagy figyelmen kívül kell-e hagynia az összehasonlítások esetét, vagy word (kultúraérzékeny) vagy sorszámos (kultúraérzékeny) rendezési szabályokat kell használnia.

Az összehasonlítás akkor fejeződik be, ha egy egyenlőtlenséget fedeznek fel, vagy mindkét részszűrést összehasonlítják. Ha azonban a két sztring egyenlő az egyik sztring végével, és a másik sztringben maradnak karakterek, a fennmaradó karakterekkel rendelkező sztring nagyobbnak minősül. A visszatérési érték az utolsó elvégzett összehasonlítás eredménye.

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, true) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, true) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, True) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Hasonlítsa össze az elérési utat a "fájl" névvel egy sorszámos összehasonlítással. Ehhez a megfelelő kód a következő:

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Megjegyzések a hívókhoz

A karakterkészletek figyelmen kívül hagyható karaktereket tartalmaznak. A Compare(String, Int32, String, Int32, Int32, StringComparison) metódus nem veszi figyelembe ezeket a karaktereket, ha nyelvi vagy kulturális szempontból érzékeny összehasonlítást végez. Ha az összehasonlításban figyelmen kívül hagyható karaktereket szeretne felismerni, adja meg a paraméter értékét Ordinal vagy OrdinalIgnoreCase értékét comparisonType .

Lásd még

A következőre érvényes:

Compare(String, Int32, String, Int32, Int32, Boolean)

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Két megadott String objektum részszűrését hasonlítja össze, figyelmen kívül hagyva vagy tiszteletben tartva az esetüket, és egy egész számot ad vissza, amely a rendezési sorrendben lévő relatív pozíciójukat jelzi.

public:
 static int Compare(System::String ^ strA, int indexA, System::String ^ strB, int indexB, int length, bool ignoreCase);

public static int Compare(string? strA, int indexA, string? strB, int indexB, int length, bool ignoreCase);

public static int Compare(string strA, int indexA, string strB, int indexB, int length, bool ignoreCase);

static member Compare : string * int * string * int * int * bool -> int

Public Shared Function Compare (strA As String, indexA As Integer, strB As String, indexB As Integer, length As Integer, ignoreCase As Boolean) As Integer

Paraméterek

strA: String

Az összehasonlításban elsőként használandó sztring.

indexA: Int32

Az alsztring pozíciója a következőn belül strA: .

strB: String

Az összehasonlításban használt második sztring.

indexB: Int32

Az alsztring pozíciója a következőn belül strB: .

length: Int32

Az összehasonlítandó alsztringek karaktereinek maximális száma.

ignoreCase: Boolean

truea kis- és nagybetűk figyelmen kívül hagyása az összehasonlítás során; egyéb esetben. false

Válaszok

Int32

Egy 32 bites aláírt egész szám, amely a két összehasonlítás és a két összehasonlítás közötti lexikális kapcsolatot jelzi.

Érték	Feltétel
Nullánál kisebb	Az alsztring `strA` a rendezési sorrendben `strB` lévő részszűrést megelőzi.
Nulla	Az alsztringek a rendezési sorrendben ugyanabban a pozícióban fordulnak elő, vagy `length` nulla.
Nullánál nagyobb	Az alászúrás `strA` a rendezési sorrendben `strB` lévő részszúrást követi.

Kivételek

ArgumentOutOfRangeException

indexA nagyobb, mint strA.Length.

-vagy-

indexB nagyobb, mint strB.Length.

-vagy-

indexA, indexBvagy length negatív.

-vagy-

indexA Vagy indexB aznull, és length nagyobb, mint nulla.

Példák

Az alábbi példa két olyan alsztring összehasonlítását hajtja végre, amelyek csak abban az esetben különböznek. Az első összehasonlítás figyelmen kívül hagyja az esetet, a második pedig az esetet.

String str1 = "MACHINE";
String str2 = "machine";
String str;
int result;

Console.WriteLine();
Console.WriteLine("str1 = '{0}', str2 = '{1}'", str1, str2);

Console.WriteLine("Ignore case:");
result = String.Compare(str1, 2, str2, 2, 2, true);
str = ((result < 0) ? "less than" : ((result > 0) ? "greater than" : "equal to"));
Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(2, 2), str1);
Console.Write("{0} ", str);
Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(2, 2), str2);
Console.WriteLine();

Console.WriteLine("Honor case:");
result = String.Compare(str1, 2, str2, 2, 2, false);
str = ((result < 0) ? "less than" : ((result > 0) ? "greater than" : "equal to"));
Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(2, 2), str1);
Console.Write("{0} ", str);
Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(2, 2), str2);

/*
This example produces the following results:

str1 = 'MACHINE', str2 = 'machine'
Ignore case:
Substring 'CH' in 'MACHINE' is equal to substring 'ch' in 'machine'.

Honor case:
Substring 'CH' in 'MACHINE' is greater than substring 'ch' in 'machine'.
*/

open System

let str1 = "MACHINE"
let str2 = "machine"

printfn $"\nstr1 = '{str1}', str2 = '{str2}'"

printfn "Ignore case:"
let result = String.Compare(str1, 2, str2, 2, 2, true)
let str = 
    if result < 0 then "less than" 
    elif result > 0 then "greater than"
    else "equal to"

printf $"Substring '{str1.Substring(2, 2)}' in '{str1}' is "
printf $"{str} "
printfn $"substring '{str2.Substring(2, 2)}' in '{str2}'.\n"

printfn "Honor case:"
let result2 = String.Compare(str1, 2, str2, 2, 2, false)
let str3 = 
    if result < 0 then "less than" 
    elif result > 0 then "greater than" 
    else "equal to"

printfn $"Substring '{str1.Substring(2, 2)}' in '{str1}' is "
printf $"{str3} "
printfn $"substring '{str2.Substring(2, 2)}' in '{str2}'."

(*
This example produces the following results:

str1 = 'MACHINE', str2 = 'machine'
Ignore case:
Substring 'CH' in 'MACHINE' is equal to substring 'ch' in 'machine'.

Honor case:
Substring 'CH' in 'MACHINE' is greater than substring 'ch' in 'machine'.
*)

' Sample for String.Compare(String, Int32, String, Int32, Int32, Boolean)
Class Sample
   
   Public Shared Sub Main()
      '                       0123456
      Dim str1 As [String] = "MACHINE"
      Dim str2 As [String] = "machine"
      Dim str As [String]
      Dim result As Integer
      
      Console.WriteLine()
      Console.WriteLine("str1 = '{0}', str2 = '{1}'", str1, str2)
      Console.WriteLine("Ignore case:")
      result = [String].Compare(str1, 2, str2, 2, 2, True)
      str = IIf(result < 0, "less than", IIf(result > 0, "greater than", "equal to"))
      Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(2, 2), str1)
      Console.Write("{0} ", str)
      Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(2, 2), str2)
      
      Console.WriteLine()
      Console.WriteLine("Honor case:")
      result = [String].Compare(str1, 2, str2, 2, 2, False)
      str = IIf(result < 0, "less than", IIf(result > 0, "greater than", "equal to"))
      Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(2, 2), str1)
      Console.Write("{0} ", str)
      Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(2, 2), str2)
   End Sub
End Class
'
'This example produces the following results:
'
'str1 = 'MACHINE', str2 = 'machine'
'Ignore case:
'Substring 'CH' in 'MACHINE' is equal to substring 'ch' in 'machine'.
'
'Honor case:
'Substring 'CH' in 'MACHINE' is greater than substring 'ch' in 'machine'.
'

Megjegyzések

A kezdő és a kezdő időpontban összehasonlítandó strAindexAstrBindexBrészszűrések. Mindkettő indexA nulla indexB alapú, vagyis az első karakter a nulla pozícióban strAstrB van. Az első részszúrás hossza mínusz strAindexA plusz egy. A második részszúrás hossza mínusz plusz egy.strBindexB

Az összehasonlítandó karakterek száma a két részsztring hosszának kisebb része, és lengtha . A indexA, indexBés length a paraméterek nem lehetnek nemegatívak.

Az összehasonlítás az aktuális kultúrát használja a kultúraspecifikus információk, például a casing szabályok és az egyes karakterek betűrendjének lekérésére. Egy kultúra például megadhatja, hogy a karakterek bizonyos kombinációi egyetlen karakterként legyenek kezelve, vagy a nagybetűket és a kisbetűket egy adott módon hasonlítsa össze, vagy hogy egy karakter rendezési sorrendje az azt megelőző vagy követő karakterektől függ.

Warning

A sztringek összehasonlításakor meg kell hívnia a Compare(String, Int32, String, Int32, Int32, StringComparison) metódust, amelyhez explicit módon meg kell adnia a metódus által használt sztring-összehasonlítás típusát. További információ: Ajánlott eljárások sztringek használatához.

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, true) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, true) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, True) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Az elérési út nevét invariáns módon kell összehasonlítani. Ehhez a megfelelő kód a következő.

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Megjegyzések a hívókhoz

A karakterkészletek figyelmen kívül hagyható karaktereket tartalmaznak. A Compare(String, Int32, String, Int32, Int32, Boolean) metódus nem veszi figyelembe ezeket a karaktereket, ha nyelvi vagy kulturális szempontból érzékeny összehasonlítást végez. Az összehasonlításban figyelmen kívül hagyható karakterek felismeréséhez hívja meg a metódust Compare(String, Int32, String, Int32, Int32, StringComparison) , és adja meg a paraméter értékét Ordinal vagy OrdinalIgnoreCase értékét comparisonType .

Lásd még

A következőre érvényes:

Compare(String, Int32, String, Int32, Int32)

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Két megadott String objektum részszűrését hasonlítja össze, és egy egész számot ad vissza, amely a rendezési sorrendben lévő relatív pozíciójukat jelzi.

public:
 static int Compare(System::String ^ strA, int indexA, System::String ^ strB, int indexB, int length);

public static int Compare(string strA, int indexA, string strB, int indexB, int length);

public static int Compare(string? strA, int indexA, string? strB, int indexB, int length);

static member Compare : string * int * string * int * int -> int

Public Shared Function Compare (strA As String, indexA As Integer, strB As String, indexB As Integer, length As Integer) As Integer

Paraméterek

strA: String

Az összehasonlításban elsőként használandó sztring.

indexA: Int32

Az alsztring pozíciója a következőn belül strA: .

strB: String

Az összehasonlításban használt második sztring.

indexB: Int32

Az alsztring pozíciója a következőn belül strB: .

length: Int32

Az összehasonlítandó alsztringek karaktereinek maximális száma.

Válaszok

Int32

32 bites aláírt egész szám, amely a két összehasonlítás és a két összehasonlítás közötti lexikális kapcsolatot jelzi.

Érték	Feltétel
Nullánál kisebb	Az alsztring `strA` a rendezési sorrendben `strB` lévő részszűrést megelőzi.
Nulla	Az alsztringek a rendezési sorrendben ugyanabban a pozícióban fordulnak elő, vagy `length` nulla.
Nullánál nagyobb	Az alászúrás `strA` a rendezési sorrendben `strB` lévő részszúrást követi.

Kivételek

ArgumentOutOfRangeException

indexA nagyobb, mint strA.Length.

-vagy-

indexB nagyobb, mint strB.Length.

-vagy-

indexA, indexBvagy length negatív.

-vagy-

indexA Vagy indexB aznull, és length nagyobb, mint nulla.

Példák

Az alábbi példa két részstringet hasonlít össze.

String str1 = "machine";
String str2 = "device";
String str;
int result;

Console.WriteLine();
Console.WriteLine("str1 = '{0}', str2 = '{1}'", str1, str2);
result = String.Compare(str1, 2, str2, 0, 2);
str = ((result < 0) ? "less than" : ((result > 0) ? "greater than" : "equal to"));
Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(2, 2), str1);
Console.Write("{0} ", str);
Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(0, 2), str2);

/*
This example produces the following results:

str1 = 'machine', str2 = 'device'
Substring 'ch' in 'machine' is less than substring 'de' in 'device'.
*/

open System

let str1 = "machine"
let str2 = "device"

printfn "\nstr1 = '{str1}', str2 = '{str2}'"

let result = String.Compare(str1, 2, str2, 0, 2)
let str = 
    if result < 0 then "less than" 
    elif result > 0 then "greater than" 
    else "equal to"

printf $"Substring '{str1.Substring(2, 2)}' in '{str1}' is "
printf $"{str} "
printfn $"substring '{str2.Substring(0, 2)}' in '{str2}'."

(*
This example produces the following results:

str1 = 'machine', str2 = 'device'
Substring 'ch' in 'machine' is less than substring 'de' in 'device'.
*)

' Sample for String.Compare(String, Int32, String, Int32, Int32)
Class Sample
   Public Shared Sub Main()
      '                       0123456
      Dim str1 As [String] = "machine"
      Dim str2 As [String] = "device"
      Dim str As [String]
      Dim result As Integer
      
      Console.WriteLine()
      Console.WriteLine("str1 = '{0}', str2 = '{1}'", str1, str2)
      result = [String].Compare(str1, 2, str2, 0, 2)
      str = IIf(result < 0, "less than", IIf(result > 0, "greater than", "equal to"))
      Console.Write("Substring '{0}' in '{1}' is ", str1.Substring(2, 2), str1)
      Console.Write("{0} ", str)
      Console.WriteLine("substring '{0}' in '{1}'.", str2.Substring(0, 2), str2)
   End Sub
End Class
'
'This example produces the following results:
'
'str1 = 'machine', str2 = 'device'
'Substring 'ch' in 'machine' is less than substring 'de' in 'device'.
'

Megjegyzések

A kezdő strAindexAstrBindexBés a kezdő időpont összehasonlítása alsztringek. Mindkettő indexA nulla indexB alapú, vagyis az első karakter a nulla pozícióban strAstrB van. Az első részszúrás hossza mínusz strAindexA plusz egy. A második részszúrás hossza mínusz plusz egy.strBindexB

Az összehasonlítandó karakterek száma a két részsztring hosszának kisebb része, és lengtha . A indexA, indexBés length a paraméterek nem lehetnek nemegatívak.

Warning

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, true) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, true) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, True) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Hasonlítsa össze az elérési utat a "fájl" névvel egy sorszámos összehasonlítással. Ehhez a megfelelő kód a következő:

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Megjegyzések a hívókhoz

A karakterkészletek figyelmen kívül hagyható karaktereket tartalmaznak. A Compare(String, Int32, String, Int32, Int32) metódus nem veszi figyelembe ezeket a karaktereket, ha nyelvi vagy kulturális szempontból érzékeny összehasonlítást végez. Az összehasonlításban figyelmen kívül hagyható karakterek felismeréséhez hívja meg a metódust Compare(String, Int32, String, Int32, Int32, StringComparison) , és adja meg a paraméter értékét Ordinal vagy OrdinalIgnoreCase értékét comparisonType .

Lásd még

A következőre érvényes:

Compare(String, String, CultureInfo, CompareOptions)

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Összehasonlít két megadott String objektumot a megadott összehasonlítási lehetőségek és kultúraspecifikus információk használatával az összehasonlítás befolyásolásához, és egy egész számot ad vissza, amely a rendezési sorrendben jelzi a két sztring egymáshoz való viszonyát.

public:
 static int Compare(System::String ^ strA, System::String ^ strB, System::Globalization::CultureInfo ^ culture, System::Globalization::CompareOptions options);

public static int Compare(string? strA, string? strB, System.Globalization.CultureInfo? culture, System.Globalization.CompareOptions options);

public static int Compare(string strA, string strB, System.Globalization.CultureInfo culture, System.Globalization.CompareOptions options);

static member Compare : string * string * System.Globalization.CultureInfo * System.Globalization.CompareOptions -> int

Public Shared Function Compare (strA As String, strB As String, culture As CultureInfo, options As CompareOptions) As Integer

Paraméterek

strA: String

Az első összehasonlítandó sztring.

strB: String

A második összehasonlítandó sztring.

culture: CultureInfo

A kultúraspecifikus összehasonlító információkat biztosító kultúra. Ha culture van null, a jelenlegi kultúrát használják.

options: CompareOptions

Az összehasonlítás során használandó beállítások (például a kis- és nagybetűk figyelmen kívül hagyása).

Válaszok

Int32

32 bites aláírt egész szám, amely a lexikális kapcsolatot strA jelzi az és strBa között, az alábbi táblázatban látható módon

Érték	Feltétel
Nullánál kisebb	`strA` `strB` rendezési sorrendben.
Nulla	`strA` ugyanabban a pozícióban történik, mint `strB` a rendezési sorrendben.
Nullánál nagyobb	`strA` `strB` rendezési sorrendben követi.

Kivételek

ArgumentException

options nem érték CompareOptions .

Példák

Az alábbi példa három különböző módon hasonlít össze két sztringet: használjon nyelvi összehasonlítást a en-US kultúrához; nyelvi kis- és nagybetűk megkülönböztetése a en-US kultúrához; és egy sorszám-összehasonlítást használ. Bemutatja, hogy a három összehasonlítási módszer hogyan hoz létre három különböző eredményt.

using System;
using System.Globalization;

public class Example0
{
    public static void Main()
    {
        string string1 = "brother";
        string string2 = "Brother";
        string relation;
        int result;

        // Cultural (linguistic) comparison.
        result = String.Compare(string1, string2, new CultureInfo("en-US"), 
                              CompareOptions.None);
        if (result > 0)
            relation = "comes after";
        else if (result == 0)
            relation = "is the same as";
        else
            relation = "comes before";

        Console.WriteLine("'{0}' {1} '{2}'.", 
                        string1, relation, string2);

        // Cultural (linguistic) case-insensitive comparison.
        result = String.Compare(string1, string2, new CultureInfo("en-US"), 
                              CompareOptions.IgnoreCase);
        if (result > 0)
            relation = "comes after";
        else if (result == 0)
            relation = "is the same as";
        else
            relation = "comes before";

        Console.WriteLine("'{0}' {1} '{2}'.", 
                        string1, relation, string2);
 
        // Culture-insensitive ordinal comparison.
        result = String.CompareOrdinal(string1, string2);
        if (result > 0)
            relation = "comes after";
        else if (result == 0)
            relation = "is the same as";
        else
            relation = "comes before";

        Console.WriteLine("'{0}' {1} '{2}'.", 
                        string1, relation, string2);

        // The example produces the following output:
        //    'brother' comes before 'Brother'.   
        //    'brother' is the same as 'Brother'.
        //    'brother' comes after 'Brother'.
    }
}

open System
open System.Globalization

let string1 = "brother"
let string2 = "Brother"

// Cultural (linguistic) comparison.
let result = String.Compare(string1, string2, CultureInfo "en-US", CompareOptions.None)
let relation =
    if result > 0 then "comes after"
    elif result = 0 then "is the same as"
    else "comes before"

printfn $"'{string1}' {relation} '{string2}'."

// Cultural (linguistic) case-insensitive comparison.
let result2 = String.Compare(string1, string2, CultureInfo "en-US", CompareOptions.IgnoreCase)
let relation2 =
    if result2 > 0 then "comes after"
    elif result2 = 0 then "is the same as"
    else "comes before"

printfn $"'{string1}' {relation2} '{string2}'."

// Culture-insensitive ordinal comparison.
let result3 = String.CompareOrdinal(string1, string2)
let relation3 =
    if result2 > 0 then "comes after"
    elif result2 = 0 then "is the same as"
    else "comes before"

printfn $"'{string1}' {relation} '{string2}'."

// The example produces the following output:
//    'brother' comes before 'Brother'.   
//    'brother' is the same as 'Brother'.
//    'brother' comes after 'Brother'.

Imports System.Globalization

Public Module Example
   Public Sub Main()
      Dim string1 As String = "brother"
      Dim string2 As String = "Brother"
      Dim relation As String
      Dim result As Integer

      ' Cultural (linguistic) comparison.
      result = String.Compare(string1, string2, _
                              New CultureInfo("en-US"), CompareOptions.None)
      If result > 0 Then
         relation = "comes after"
      ElseIf result = 0 Then
         relation = "is the same as"
      Else
         relation = "comes before"
      End If
      Console.WriteLine("'{0}' {1} '{2}'.", string1, relation, string2)

      ' Cultural (linguistic) case-insensitive comparison.
      result = String.Compare(string1, string2, _
                              New CultureInfo("en-US"), CompareOptions.IgnoreCase)
      If result > 0 Then
         relation = "comes after"
      ElseIf result = 0 Then
         relation = "is the same as"
      Else
         relation = "comes before"
      End If
      Console.WriteLine("'{0}' {1} '{2}'.", string1, relation, string2)

      ' Culture-insensitive ordinal comparison.
      result = String.CompareOrdinal(string1, string2)
      If result > 0 Then
         relation = "comes after"
      ElseIf result = 0 Then
         relation = "is the same as"
      Else
         relation = "comes before"
      End If
      Console.WriteLine("'{0}' {1} '{2}'.", string1, relation, string2)
   End Sub
End Module
' The example produces the following output:
'    'brother' comes before 'Brother'.   
'    'brother' is the same as 'Brother'.
'    'brother' comes after 'Brother'.

Megjegyzések

Figyelmeztetés

A Compare(String, String, CultureInfo, CompareOptions) metódus elsősorban rendezési vagy betűrendezési műveletekhez használható. Nem használható, ha a metódushívás elsődleges célja annak megállapítása, hogy két sztring egyenértékű-e (vagyis amikor a metódushívás célja a nulla visszatérési érték tesztelése). Annak megállapításához, hogy két sztring egyenértékű-e, hívja meg a metódust Equals .

Az összehasonlítást tovább lehet adni a options paraméterrel, amely az CompareOptions enumerálás egy vagy több tagját tartalmazza. Mivel azonban ennek a módszernek a célja a kultúraérzékeny sztringek összehasonlítása, az CompareOptions.Ordinal értékeknek CompareOptions.OrdinalIgnoreCase nincs hatása.

Vagy mindkét összehasonlítása lehet null. Definíció szerint minden sztring , beleértve a String.Emptynullhivatkozásnál nagyobbat is, és két nullhivatkozás egyenlő egymással.

Az összehasonlítás akkor fejeződik be, ha egy egyenlőtlenséget észlel, vagy mindkét sztringet összehasonlítják. Ha azonban a két sztring az egyik sztring végével egyenlő, a másik sztringben pedig maradnak karakterek, akkor a fennmaradó karakterekkel rendelkező sztring nagyobbnak minősül.

Megjegyzések a hívókhoz

A karakterkészletek figyelmen kívül hagyható karaktereket tartalmaznak, amelyek nyelvi vagy kulturális szempontból érzékeny összehasonlítások során nem figyelembe vett karakterek. A Compare(String, String, CultureInfo, CompareOptions) metódus nem veszi figyelembe az ilyen karaktereket, ha kulturális szempontból érzékeny összehasonlítást végez. Ha az összehasonlításban figyelmen kívül hagyható karaktereket szeretne felismerni, adja meg a paraméter értékét Ordinal vagy OrdinalIgnoreCase értékét options .

Lásd még

A következőre érvényes:

Compare(String, String, Boolean, CultureInfo)

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Összehasonlít két megadott String objektumot, figyelmen kívül hagyva vagy tiszteletben tartva az esetüket, és kultúraspecifikus információkat használ az összehasonlítás befolyásolására, és egy egész számot ad vissza, amely a rendezési sorrendben elfoglalt relatív pozíciójukat jelzi.

public:
 static int Compare(System::String ^ strA, System::String ^ strB, bool ignoreCase, System::Globalization::CultureInfo ^ culture);

public static int Compare(string? strA, string? strB, bool ignoreCase, System.Globalization.CultureInfo? culture);

public static int Compare(string strA, string strB, bool ignoreCase, System.Globalization.CultureInfo culture);

static member Compare : string * string * bool * System.Globalization.CultureInfo -> int

Public Shared Function Compare (strA As String, strB As String, ignoreCase As Boolean, culture As CultureInfo) As Integer

Paraméterek

strA: String

Az első összehasonlítandó sztring.

strB: String

A második összehasonlítandó sztring.

ignoreCase: Boolean

truea kis- és nagybetűk figyelmen kívül hagyása az összehasonlítás során; egyéb esetben. false

culture: CultureInfo

Egy objektum, amely kultúraspecifikus összehasonlító információkat szolgáltat. Ha culture van null, a jelenlegi kultúrát használják.

Válaszok

Int32

Egy 32 bites aláírt egész szám, amely a két összehasonlítás és a két összehasonlítás közötti lexikális kapcsolatot jelzi.

Érték	Feltétel
Nullánál kisebb	`strA` `strB` rendezési sorrendben.
Nulla	`strA` ugyanabban a pozícióban történik, mint `strB` a rendezési sorrendben.
Nullánál nagyobb	`strA` `strB` rendezési sorrendben követi.

Példák

Az alábbi példa bemutatja, hogyan befolyásolhatja a kultúra az összehasonlítást. Cseh - Cseh Köztársaság kultúrában a "ch" egyetlen karakter, amely nagyobb, mint a "d". Azonban angolul - Egyesült Államok kultúrában a "ch" két karakterből áll, és a "c" kisebb, mint a "d".

public static void Main()
{
    String str1 = "change";
    String str2 = "dollar";
    String relation;

    relation = symbol(String.Compare(str1, str2, false, new CultureInfo("en-US")));
    Console.WriteLine("For en-US: {0} {1} {2}", str1, relation, str2);

    relation = symbol(String.Compare(str1, str2, false, new CultureInfo("cs-CZ")));
    Console.WriteLine("For cs-CZ: {0} {1} {2}", str1, relation, str2);
}

private static String symbol(int r)
{
    String s = "=";
    if (r < 0) s = "<";
    else if (r > 0) s = ">";
    return s;
}

/*
This example produces the following results.
For en-US: change < dollar
For cs-CZ: change > dollar
*/

let symbol r =
    if r < 0 then "<"
    elif r > 0 then ">"
    else "="

let str1 = "change"
let str2 = "dollar"

let relation1 = 
    String.Compare(str1, str2, false, CultureInfo "en-US")
    |> symbol
printfn $"For en-US: {str1} {relation1} {str2}"

let relation2 = 
    String.Compare(str1, str2, false, CultureInfo "cs-CZ")
    |> symbol
printfn $"For cs-CZ: {str1} {relation2} {str2}"

(*
This example produces the following results.
For en-US: change < dollar
For cs-CZ: change > dollar
*)

Imports System.Globalization
 _

Class Sample
   Public Shared Sub Main()
      Dim str1 As [String] = "change"
      Dim str2 As [String] = "dollar"
      Dim relation As [String] = Nothing
      
      relation = symbol([String].Compare(str1, str2, False, New CultureInfo("en-US")))
      Console.WriteLine("For en-US: {0} {1} {2}", str1, relation, str2)
      
      relation = symbol([String].Compare(str1, str2, False, New CultureInfo("cs-CZ")))
      Console.WriteLine("For cs-CZ: {0} {1} {2}", str1, relation, str2)
   End Sub
   
   Private Shared Function symbol(r As Integer) As [String]
      Dim s As [String] = "="
      If r < 0 Then
         s = "<"
      Else
         If r > 0 Then
            s = ">"
         End If
      End If
      Return s
   End Function 'symbol
End Class
'
'This example produces the following results.
'For en-US: change < dollar
'For cs-CZ: change > dollar
'

Megjegyzések

Az összehasonlítás akkor fejeződik be, ha egy egyenlőtlenséget észlel, vagy mindkét sztringet összehasonlítják. Ha azonban a két sztring egyenlő az egyik sztring végével, a másik sztringben pedig maradnak karakterek, akkor a fennmaradó karakterekkel rendelkező sztring nagyobbnak minősül. A visszatérési érték az utolsó elvégzett összehasonlítás eredménye.

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, true) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, true) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, True) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Hasonlítsa össze az elérési utat a "fájl" névvel egy sorszámos összehasonlítással. Ehhez a megfelelő kód a következő:

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Megjegyzések a hívókhoz

A karakterkészletek figyelmen kívül hagyható karaktereket tartalmaznak. A Compare(String, String, Boolean, CultureInfo) metódus nem veszi figyelembe az ilyen karaktereket, ha kulturális szempontból érzékeny összehasonlítást végez. Ha például a következő kód a .NET Framework 4-es vagy újabb verzióján fut, az "animal" és az "Ani-mal" esetérzékeny összehasonlítása (puha kötőjel vagy U+00AD használatával) az invariáns kultúra használatával azt jelzi, hogy a két sztring egyenértékű.

  string s1 = "Ani\u00ADmal";
  string s2 = "animal";

  Console.WriteLine("Comparison of '{0}' and '{1}': {2}", 
                  s1, s2, String.Compare(s1, s2, true,
                  CultureInfo.InvariantCulture));

  // The example displays the following output:
  //       Comparison of 'Ani-mal' and 'animal': 0

open System
open System.Globalization

let s1 = "Ani\u00ADmal"
let s2 = "animal"

printfn $"Comparison of '{s1}' and '{s2}': {String.Compare(s1, s2, true, CultureInfo.InvariantCulture)}"

// The example displays the following output:
//       Comparison of 'Ani-mal' and 'animal': 0

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim s1 As String = "Ani" + ChrW(&h00AD) + "mal"
      Dim s2 As String = "animal"
      
      Console.WriteLine("Comparison of '{0}' and '{1}': {2}", 
                        s1, s2, String.Compare(s1, s2, True,
                        CultureInfo.InvariantCulture))
  End Sub
End Module
' The example displays the following output:
'       Comparison of 'ani-mal' and 'animal': 0

A sztring-összehasonlításban figyelmen kívül hagyható karakterek felismeréséhez hívja meg a Compare(String, String, CultureInfo, CompareOptions) metódust, és adjon meg egy értéket vagy Ordinal OrdinalIgnoreCase a options paramétert.

Lásd még

A következőre érvényes:

Compare(String, String, StringComparison)

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Két megadott String objektumot hasonlít össze a megadott szabályokkal, és egy egész számot ad vissza, amely a rendezési sorrendben lévő relatív pozíciójukat jelzi.

public:
 static int Compare(System::String ^ strA, System::String ^ strB, StringComparison comparisonType);

public static int Compare(string strA, string strB, StringComparison comparisonType);

public static int Compare(string? strA, string? strB, StringComparison comparisonType);

static member Compare : string * string * StringComparison -> int

Public Shared Function Compare (strA As String, strB As String, comparisonType As StringComparison) As Integer

Paraméterek

strA: String

Az első összehasonlítandó sztring.

strB: String

A második összehasonlítandó sztring.

comparisonType: StringComparison

Az összehasonlításban használandó szabályokat meghatározó számbavételi értékek egyike.

Válaszok

Int32

Egy 32 bites aláírt egész szám, amely a két összehasonlítás és a két összehasonlítás közötti lexikális kapcsolatot jelzi.

Érték	Feltétel
Nullánál kisebb	`strA` `strB` rendezési sorrendben.
Nulla	`strA` ugyanabban a helyzetben van, mint `strB` a rendezési sorrendben.
Nullánál nagyobb	`strA` `strB` rendezési sorrendben követi.

Kivételek

ArgumentException

comparisonType nem érték StringComparison .

NotSupportedException

StringComparison nem támogatott.

Példák

Az alábbi példa az "I" betű három verzióját hasonlítja össze. Az eredményeket befolyásolja a kultúra megválasztása, az eset figyelmen kívül hagyása, valamint az, hogy a rendszer végrehajtja-e a rendezési összehasonlítást.

// This example demonstrates the 
// System.String.Compare(String, String, StringComparison) method.

using System;
using System.Threading;

class Sample 
{
    public static void Main() 
    {
        string intro = "Compare three versions of the letter I using different " + 
                       "values of StringComparison.";

        // Define an array of strings where each element contains a version of the 
        // letter I. (An array of strings is used so you can easily modify this 
        // code example to test additional or different combinations of strings.)  

        string[] threeIs = new string[3];
        // LATIN SMALL LETTER I (U+0069)
        threeIs[0] = "\u0069";
        // LATIN SMALL LETTER DOTLESS I (U+0131)
        threeIs[1] = "\u0131";
        // LATIN CAPITAL LETTER I (U+0049)
        threeIs[2] = "\u0049";

        string[] unicodeNames = 
        {
            "LATIN SMALL LETTER I (U+0069)", 
            "LATIN SMALL LETTER DOTLESS I (U+0131)", 
            "LATIN CAPITAL LETTER I (U+0049)"
        };

        StringComparison[] scValues =
        {
            StringComparison.CurrentCulture,
            StringComparison.CurrentCultureIgnoreCase,
            StringComparison.InvariantCulture,
            StringComparison.InvariantCultureIgnoreCase,
            StringComparison.Ordinal,
            StringComparison.OrdinalIgnoreCase
        };

        Console.Clear();
        Console.WriteLine(intro);

        // Display the current culture because the culture-specific comparisons
        // can produce different results with different cultures.
        Console.WriteLine(
            "The current culture is {0}.\n", Thread.CurrentThread.CurrentCulture.Name);

        // Determine the relative sort order of three versions of the letter I. 
        foreach (StringComparison sc in scValues)
        {
            Console.WriteLine("StringComparison.{0}:", sc);

            // LATIN SMALL LETTER I (U+0069) : LATIN SMALL LETTER DOTLESS I (U+0131)
            Test(0, 1, sc, threeIs, unicodeNames);

            // LATIN SMALL LETTER I (U+0069) : LATIN CAPITAL LETTER I (U+0049)
            Test(0, 2, sc, threeIs, unicodeNames);

            // LATIN SMALL LETTER DOTLESS I (U+0131) : LATIN CAPITAL LETTER I (U+0049)
            Test(1, 2, sc, threeIs, unicodeNames);

            Console.WriteLine();
        }
    }

    protected static void Test(
        int x, int y, StringComparison comparison, string[] testI, string[] testNames)
    {
        string resultFmt = "{0} is {1} {2}";
        string result = "equal to";
        int cmpValue = 0;

        cmpValue = String.Compare(testI[x], testI[y], comparison);
        if (cmpValue < 0)
            result = "less than";
        else if (cmpValue > 0)
            result = "greater than";
        Console.WriteLine(resultFmt, testNames[x], result, testNames[y]);
    }
}

/*
This code example produces the following results:

Compare three versions of the letter I using different values of StringComparison.
The current culture is en-US.

StringComparison.CurrentCulture:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is less than LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

StringComparison.CurrentCultureIgnoreCase:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is equal to LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

StringComparison.InvariantCulture:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is less than LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

StringComparison.InvariantCultureIgnoreCase:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is equal to LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

StringComparison.Ordinal:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is greater than LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

StringComparison.OrdinalIgnoreCase:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is equal to LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

*/

// This example demonstrates the 
// System.String.Compare(String, String, StringComparison) method.

open System
open System.Threading

let test x y (comparison: StringComparison) (testI: string[]) (testNames: string[]) =
    let cmpValue = String.Compare(testI[x], testI[y], comparison)
    let result =
        if cmpValue < 0 then
            "less than"
        elif cmpValue > 0 then
            "greater than"
        else
            "equal to"
    printfn $"{testNames[x]} is {result} {testNames[y]}"

let intro = "Compare three versions of the letter I using different values of StringComparison."

// Define an array of strings where each element contains a version of the 
// letter I. (An array of strings is used so you can easily modify this 
// code example to test additional or different combinations of strings.)  

let threeIs = 
  [|// LATIN SMALL LETTER I (U+0069)
    "\u0069"
    // LATIN SMALL LETTER DOTLESS I (U+0131)
    "\u0131"
    // LATIN CAPITAL LETTER I (U+0049)
    "\u0049" |]

let unicodeNames =
    [| "LATIN SMALL LETTER I (U+0069)"
       "LATIN SMALL LETTER DOTLESS I (U+0131)"
       "LATIN CAPITAL LETTER I (U+0049)" |]

let scValues =
    [| StringComparison.CurrentCulture
       StringComparison.CurrentCultureIgnoreCase
       StringComparison.InvariantCulture
       StringComparison.InvariantCultureIgnoreCase
       StringComparison.Ordinal
       StringComparison.OrdinalIgnoreCase |]

Console.Clear()
printfn $"{intro}"

// Display the current culture because the culture-specific comparisons
// can produce different results with different cultures.
printfn $"The current culture is {Thread.CurrentThread.CurrentCulture.Name}.\n"

// Determine the relative sort order of three versions of the letter I. 
for sc in scValues do
    printfn $"StringComparison.{sc}:"

    // LATIN SMALL LETTER I (U+0069) : LATIN SMALL LETTER DOTLESS I (U+0131)
    test 0 1 sc threeIs unicodeNames

    // LATIN SMALL LETTER I (U+0069) : LATIN CAPITAL LETTER I (U+0049)
    test 0 2 sc threeIs unicodeNames

    // LATIN SMALL LETTER DOTLESS I (U+0131) : LATIN CAPITAL LETTER I (U+0049)
    test 1 2 sc threeIs unicodeNames

    printfn ""

(*
This code example produces the following results:

Compare three versions of the letter I using different values of StringComparison.
The current culture is en-US.

StringComparison.CurrentCulture:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is less than LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

StringComparison.CurrentCultureIgnoreCase:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is equal to LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

StringComparison.InvariantCulture:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is less than LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

StringComparison.InvariantCultureIgnoreCase:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is equal to LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

StringComparison.Ordinal:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is greater than LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)

StringComparison.OrdinalIgnoreCase:
LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
LATIN SMALL LETTER I (U+0069) is equal to LATIN CAPITAL LETTER I (U+0049)
LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)
*)

' This example demonstrates the 
' System.String.Compare(String, String, StringComparison) method.

Imports System.Threading

Class Sample
    Public Shared Sub Main() 
        Dim intro As String = "Compare three versions of the letter I using different " & _
                              "values of StringComparison."
        
        ' Define an array of strings where each element contains a version of the 
        ' letter I. (An array of strings is used so you can easily modify this 
        ' code example to test additional or different combinations of strings.)  
        Dim threeIs(2) As String
        ' LATIN SMALL LETTER I (U+0069)
        threeIs(0) = "i"
        ' LATIN SMALL LETTER DOTLESS I (U+0131)
        threeIs(1) = "ı"
        ' LATIN CAPITAL LETTER I (U+0049)
        threeIs(2) = "I"
        
        Dim unicodeNames As String() =  { _
                            "LATIN SMALL LETTER I (U+0069)", _
                            "LATIN SMALL LETTER DOTLESS I (U+0131)", _
                            "LATIN CAPITAL LETTER I (U+0049)" }
        
        Dim scValues As StringComparison() =  { _
                            StringComparison.CurrentCulture, _
                            StringComparison.CurrentCultureIgnoreCase, _
                            StringComparison.InvariantCulture, _
                            StringComparison.InvariantCultureIgnoreCase, _
                            StringComparison.Ordinal, _
                            StringComparison.OrdinalIgnoreCase }
        '
        Console.Clear()
        Console.WriteLine(intro)
        
        ' Display the current culture because the culture-specific comparisons
        ' can produce different results with different cultures.
        Console.WriteLine("The current culture is {0}." & vbCrLf, _
                           Thread.CurrentThread.CurrentCulture.Name)
        
        ' Determine the relative sort order of three versions of the letter I. 
        Dim sc As StringComparison
        For Each sc In  scValues
            Console.WriteLine("StringComparison.{0}:", sc)
            
            ' LATIN SMALL LETTER I (U+0069) : LATIN SMALL LETTER DOTLESS I (U+0131)
            Test(0, 1, sc, threeIs, unicodeNames)
            
            ' LATIN SMALL LETTER I (U+0069) : LATIN CAPITAL LETTER I (U+0049)
            Test(0, 2, sc, threeIs, unicodeNames)
            
            ' LATIN SMALL LETTER DOTLESS I (U+0131) : LATIN CAPITAL LETTER I (U+0049)
            Test(1, 2, sc, threeIs, unicodeNames)
            
            Console.WriteLine()
        Next sc
    
    End Sub
    
    Protected Shared Sub Test(ByVal x As Integer, ByVal y As Integer, _
                              ByVal comparison As StringComparison, _
                              ByVal testI() As String, ByVal testNames() As String) 
        Dim resultFmt As String = "{0} is {1} {2}"
        Dim result As String = "equal to"
        Dim cmpValue As Integer = 0
        '
        cmpValue = String.Compare(testI(x), testI(y), comparison)
        If cmpValue < 0 Then
            result = "less than"
        ElseIf cmpValue > 0 Then
            result = "greater than"
        End If
        Console.WriteLine(resultFmt, testNames(x), result, testNames(y))
    
    End Sub
End Class

'
'This code example produces the following results:
'
'Compare three versions of the letter I using different values of StringComparison.
'The current culture is en-US.
'
'StringComparison.CurrentCulture:
'LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
'LATIN SMALL LETTER I (U+0069) is less than LATIN CAPITAL LETTER I (U+0049)
'LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)
'
'StringComparison.CurrentCultureIgnoreCase:
'LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
'LATIN SMALL LETTER I (U+0069) is equal to LATIN CAPITAL LETTER I (U+0049)
'LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)
'
'StringComparison.InvariantCulture:
'LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
'LATIN SMALL LETTER I (U+0069) is less than LATIN CAPITAL LETTER I (U+0049)
'LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)
'
'StringComparison.InvariantCultureIgnoreCase:
'LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
'LATIN SMALL LETTER I (U+0069) is equal to LATIN CAPITAL LETTER I (U+0049)
'LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)
'
'StringComparison.Ordinal:
'LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
'LATIN SMALL LETTER I (U+0069) is greater than LATIN CAPITAL LETTER I (U+0049)
'LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)
'
'StringComparison.OrdinalIgnoreCase:
'LATIN SMALL LETTER I (U+0069) is less than LATIN SMALL LETTER DOTLESS I (U+0131)
'LATIN SMALL LETTER I (U+0069) is equal to LATIN CAPITAL LETTER I (U+0049)
'LATIN SMALL LETTER DOTLESS I (U+0131) is greater than LATIN CAPITAL LETTER I (U+0049)
'

Megjegyzések

Az összehasonlítás akkor fejeződik be, ha egy egyenlőtlenséget észlel, vagy mindkét sztringet összehasonlítják. Ha azonban a két sztring egyenlő az egyik sztring végével, és a másik sztringben maradnak karakterek, a fennmaradó karakterekkel rendelkező sztring nagyobbnak minősül. A visszatérési érték az utolsó elvégzett összehasonlítás eredménye.

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, true) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, true) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, True) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Hasonlítsa össze az elérési utat a "fájl" névvel egy sorszámos összehasonlítással. Ehhez a megfelelő kód a következő:

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Megjegyzések a hívókhoz

A karakterkészletek figyelmen kívül hagyható karaktereket tartalmaznak. A Compare(String, String, StringComparison) metódus nem veszi figyelembe az ilyen karaktereket, ha kulturális szempontból érzékeny összehasonlítást végez. Ha az összehasonlításban figyelmen kívül hagyható karaktereket szeretne felismerni, adja meg a paraméter értékét Ordinal vagy OrdinalIgnoreCase értékét comparisonType .

Lásd még

A következőre érvényes:

Compare(String, String, Boolean)

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Összehasonlít két megadott String objektumot, figyelmen kívül hagyva vagy tiszteletben tartva az esetüket, és egy egész számot ad vissza, amely a rendezési sorrendben lévő relatív pozíciójukat jelzi.

public:
 static int Compare(System::String ^ strA, System::String ^ strB, bool ignoreCase);

public static int Compare(string strA, string strB, bool ignoreCase);

public static int Compare(string? strA, string? strB, bool ignoreCase);

static member Compare : string * string * bool -> int

Public Shared Function Compare (strA As String, strB As String, ignoreCase As Boolean) As Integer

Paraméterek

strA: String

Az első összehasonlítandó sztring.

strB: String

A második összehasonlítandó sztring.

ignoreCase: Boolean

truea kis- és nagybetűk figyelmen kívül hagyása az összehasonlítás során; egyéb esetben. false

Válaszok

Int32

Egy 32 bites aláírt egész szám, amely a két összehasonlítás és a két összehasonlítás közötti lexikális kapcsolatot jelzi.

Érték	Feltétel
Nullánál kisebb	`strA` `strB` rendezési sorrendben.
Nulla	`strA` ugyanabban a pozícióban történik, mint `strB` a rendezési sorrendben.
Nullánál nagyobb	`strA` `strB` rendezési sorrendben követi.

Példák

Az alábbi példa bemutatja, hogy a metódus egyenértékű a Compare(String, String, Boolean) sztringek használatával ToUpper vagy ToLower összehasonlításával.

// Create upper-case characters from their Unicode code units.
String stringUpper = "\x0041\x0042\x0043";

// Create lower-case characters from their Unicode code units.
String stringLower = "\x0061\x0062\x0063";

// Display the strings.
Console.WriteLine("Comparing '{0}' and '{1}':", 
                stringUpper, stringLower);

// Compare the uppercased strings; the result is true.
Console.WriteLine("The Strings are equal when capitalized? {0}",
                String.Compare(stringUpper.ToUpper(), stringLower.ToUpper()) == 0 
                               ? "true" : "false");

// The previous method call is equivalent to this Compare method, which ignores case.
Console.WriteLine("The Strings are equal when case is ignored? {0}",
                String.Compare(stringUpper, stringLower, true) == 0
                               ? "true" : "false" );

// The example displays the following output:
//       Comparing 'ABC' and 'abc':
//       The Strings are equal when capitalized? true
//       The Strings are equal when case is ignored? true

open System

// Create upper-case characters from their Unicode code units.
let stringUpper = "\x0041\x0042\x0043"

// Create lower-case characters from their Unicode code units.
let stringLower = "\x0061\x0062\x0063"

// Display the strings.
printfn $"Comparing '{stringUpper}' and '{stringLower}':"

// Compare the uppercased strings the result is true.
printfn $"The Strings are equal when capitalized? %b{String.Compare(stringUpper.ToUpper(), stringLower.ToUpper()) = 0}"

// The previous method call is equivalent to this Compare method, which ignores case.
printfn $"The Strings are equal when case is ignored? %b{String.Compare(stringUpper, stringLower, true) = 0}"

// The example displays the following output:
//       Comparing 'ABC' and 'abc':
//       The Strings are equal when capitalized? true
//       The Strings are equal when case is ignored? true

Public Module Example
   Public Sub Main()
      ' Create upper-case characters from their Unicode code units.
      Dim stringUpper As String = ChrW(&H41) + ChrW(&H42) + ChrW(&H43)

      ' Create lower-case characters from their Unicode code units.
      Dim stringLower As String = ChrW(&H61) + ChrW(&H62) + ChrW(&H63)

      ' Display the strings.
      Console.WriteLine("Comparing '{0}' and '{1}':", 
                        stringUpper, stringLower)

      ' Compare the uppercased strings; the result is true.
      Console.WriteLine("The Strings are equal when capitalized? {0}",
                        If(String.Compare(stringUpper.ToUpper(), stringLower.ToUpper()) = 0, 
                                          "true", "false"))

      ' The previous method call is equivalent to this Compare method, which ignores case.
      Console.WriteLine("The Strings are equal when case is ignored? {0}",
                        If(String.Compare(stringUpper, stringLower, true) = 0,
                                          "true", "false"))
   End Sub
End Module 
' The example displays the following output:
'       Comparing 'ABC' and 'abc':
'       The Strings are equal when capitalized? true
'       The Strings are equal when case is ignored? true

Megjegyzések

Warning

A sztringek összehasonlításakor meg kell hívnia a Compare(String, String, StringComparison) metódust, amelyhez explicit módon meg kell adnia a metódus által használt sztring-összehasonlítás típusát. További információ: Ajánlott eljárások sztringek használatához.

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, true) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, true) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, True) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Hasonlítsa össze az elérési utat a "fájl" névvel egy sorszámos összehasonlítással. Ehhez a megfelelő kód a következő:

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Megjegyzések a hívókhoz

A karakterkészletek figyelmen kívül hagyható karaktereket tartalmaznak. A Compare(String, String, Boolean) metódus nem veszi figyelembe az ilyen karaktereket, ha kulturális szempontból érzékeny összehasonlítást végez. Az "állat" és az "Ani-mal" (puha kötőjel vagy U+00AD) kultúraérzékeny, kis- és nagybetűs összehasonlítása például azt jelzi, hogy a két sztring egyenértékű.

string s1 = "Ani\u00ADmal";
string s2 = "animal";

Console.WriteLine("Comparison of '{0}' and '{1}': {2}",
                s1, s2, String.Compare(s1, s2, true));

// The example displays the following output:
//       Comparison of 'Ani-mal' and 'animal': 0

open System

let s1 = "Ani\u00ADmal"
let s2 = "animal"

printfn $"Comparison of '{s1}' and '{s2}': {String.Compare(s1, s2, true)}"

// The example displays the following output:
//       Comparison of 'Ani-mal' and 'animal': 0

Module Example
   Public Sub Main()
      Dim s1 As String = "Ani" + ChrW(&h00AD) + "mal"
      Dim s2 As String = "animal"
      
      Console.WriteLine("Comparison of '{0}' and '{1}': {2}", 
                        s1, s2, String.Compare(s1, s2, True))
  End Sub
End Module
' The example displays the following output:
'       Comparison of 'ani-mal' and 'animal': 0

A sztring-összehasonlításban figyelmen kívül hagyható karakterek felismeréséhez hívja meg a Compare(String, String, StringComparison) metódust, és adjon meg egy értéket vagy Ordinal OrdinalIgnoreCase a comparisonType paramétert.

Lásd még

A következőre érvényes:

Compare(String, String)

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Forrás:: String.Comparison.cs

Összehasonlít két megadott String objektumot, és egy egész számot ad vissza, amely a rendezési sorrendben lévő relatív pozíciójukat jelzi.

public:
 static int Compare(System::String ^ strA, System::String ^ strB);

public static int Compare(string strA, string strB);

public static int Compare(string? strA, string? strB);

static member Compare : string * string -> int

Public Shared Function Compare (strA As String, strB As String) As Integer

Paraméterek

strA: String

Az első összehasonlítandó sztring.

strB: String

A második összehasonlítandó sztring.

Válaszok

Int32

Egy 32 bites aláírt egész szám, amely a két összehasonlítás és a két összehasonlítás közötti lexikális kapcsolatot jelzi.

Érték	Feltétel
Nullánál kisebb	`strA` `strB` rendezési sorrendben.
Nulla	`strA` ugyanabban a pozícióban történik, mint `strB` a rendezési sorrendben.
Nullánál nagyobb	`strA` `strB` rendezési sorrendben követi.

Példák

Az alábbi példa három sztringkészlet összehasonlítására hívja meg a Compare(String, String) metódust.

// Create upper-case characters from their Unicode code units.
String stringUpper = "\x0041\x0042\x0043";

// Create lower-case characters from their Unicode code units.
String stringLower = "\x0061\x0062\x0063";

// Display the strings.
Console.WriteLine("Comparing '{0}' and '{1}':", 
                stringUpper, stringLower);

// Compare the uppercased strings; the result is true.
Console.WriteLine("The Strings are equal when capitalized? {0}",
                String.Compare(stringUpper.ToUpper(), stringLower.ToUpper()) == 0 
                               ? "true" : "false");

// The previous method call is equivalent to this Compare method, which ignores case.
Console.WriteLine("The Strings are equal when case is ignored? {0}",
                String.Compare(stringUpper, stringLower, true) == 0
                               ? "true" : "false" );

// The example displays the following output:
//       Comparing 'ABC' and 'abc':
//       The Strings are equal when capitalized? true
//       The Strings are equal when case is ignored? true

open System

// Create upper-case characters from their Unicode code units.
let stringUpper = "\x0041\x0042\x0043"

// Create lower-case characters from their Unicode code units.
let stringLower = "\x0061\x0062\x0063"

// Display the strings.
printfn $"Comparing '{stringUpper}' and '{stringLower}':"

// Compare the uppercased strings the result is true.
printfn $"The Strings are equal when capitalized? %b{String.Compare(stringUpper.ToUpper(), stringLower.ToUpper()) = 0}"

// The previous method call is equivalent to this Compare method, which ignores case.
printfn $"The Strings are equal when case is ignored? %b{String.Compare(stringUpper, stringLower, true) = 0}"

// The example displays the following output:
//       Comparing 'ABC' and 'abc':
//       The Strings are equal when capitalized? true
//       The Strings are equal when case is ignored? true

Public Module Example
   Public Sub Main()
      ' Create upper-case characters from their Unicode code units.
      Dim stringUpper As String = ChrW(&H41) + ChrW(&H42) + ChrW(&H43)

      ' Create lower-case characters from their Unicode code units.
      Dim stringLower As String = ChrW(&H61) + ChrW(&H62) + ChrW(&H63)

      ' Display the strings.
      Console.WriteLine("Comparing '{0}' and '{1}':", 
                        stringUpper, stringLower)

      ' Compare the uppercased strings; the result is true.
      Console.WriteLine("The Strings are equal when capitalized? {0}",
                        If(String.Compare(stringUpper.ToUpper(), stringLower.ToUpper()) = 0, 
                                          "true", "false"))

      ' The previous method call is equivalent to this Compare method, which ignores case.
      Console.WriteLine("The Strings are equal when case is ignored? {0}",
                        If(String.Compare(stringUpper, stringLower, true) = 0,
                                          "true", "false"))
   End Sub
End Module 
' The example displays the following output:
'       Comparing 'ABC' and 'abc':
'       The Strings are equal when capitalized? true
'       The Strings are equal when case is ignored? true

Az alábbi példában az ReverseStringComparer osztály bemutatja, hogyan értékelhet ki két sztringet a Compare metódussal.

using System;
using System.Text;
using System.Collections;

public class SamplesArrayList
{

    public static void Main()
    {
        // Creates and initializes a new ArrayList.
        ArrayList myAL = new ArrayList();
        myAL.Add("Eric");
        myAL.Add("Mark");
        myAL.Add("Lance");
        myAL.Add("Rob");
        myAL.Add("Kris");
        myAL.Add("Brad");
        myAL.Add("Kit");
        myAL.Add("Bradley");
        myAL.Add("Keith");
        myAL.Add("Susan");

        // Displays the properties and values of	the	ArrayList.
        Console.WriteLine("Count: {0}", myAL.Count);

        PrintValues("Unsorted", myAL);
        myAL.Sort();
        PrintValues("Sorted", myAL);
        myAL.Sort(new ReverseStringComparer());
        PrintValues("Reverse", myAL);

        string[] names = (string[])myAL.ToArray(typeof(string));
    }
    public static void PrintValues(string title, IEnumerable myList)
    {
        Console.Write("{0,10}: ", title);
        StringBuilder sb = new StringBuilder();
        foreach (string s in myList)
        {
            sb.AppendFormat("{0}, ", s);
        }
        sb.Remove(sb.Length - 2, 2);
        Console.WriteLine(sb);
    }
}
public class ReverseStringComparer : IComparer
{
    public int Compare(object? x, object? y)
    {
        string? s1 = x as string;
        string? s2 = y as string;
        //negate the return value to get the reverse order
        return -String.Compare(s1, s2);
    }
}

open System
open System.Text
open System.Collections.Generic

type ReverseStringComparer() =
    interface IComparer<string> with
        member _.Compare(x, y) =
            -String.Compare(x, y)

let printValues title (myList: #seq<string>) =
    printf $"{title,10}: "
    let sb = StringBuilder()
    for s in myList do
        sb.Append $"{s}, " |> ignore
    sb.Remove(sb.Length - 2, 2) |> ignore
    printfn $"{sb}"

// Creates and initializes a new ResizeArray.
let myAL = ResizeArray()
myAL.Add "Eric"
myAL.Add "Mark"
myAL.Add "Lance"
myAL.Add "Rob"
myAL.Add "Kris"
myAL.Add "Brad"
myAL.Add "Kit"
myAL.Add "Bradley"
myAL.Add "Keith"
myAL.Add "Susan"

// Displays the properties and values of	the	ArrayList.
printfn $"Count: {myAL.Count}"

printValues "Unsorted" myAL
myAL.Sort()
printValues "Sorted" myAL
myAL.Sort(ReverseStringComparer())
printValues "Reverse" myAL

Imports System.Text
Imports System.Collections



Public Class SamplesArrayList
    
    
    Public Shared Sub Main()
        Dim myAL As New ArrayList()
        ' Creates and initializes a new ArrayList.
        myAL.Add("Eric")
        myAL.Add("Mark")
        myAL.Add("Lance")
        myAL.Add("Rob")
        myAL.Add("Kris")
        myAL.Add("Brad")
        myAL.Add("Kit")
        myAL.Add("Bradley")
        myAL.Add("Keith")
        myAL.Add("Susan")
        
        ' Displays the properties and values of	the	ArrayList.
        Console.WriteLine("Count: {0}", myAL.Count)
        PrintValues("Unsorted", myAL)
        myAL.Sort()
        PrintValues("Sorted", myAL)
        Dim comp as New ReverseStringComparer
        myAL.Sort(comp)
        PrintValues("Reverse", myAL)

        Dim names As String() = CType(myAL.ToArray(GetType(String)), String())
    End Sub
   
   
    
    Public Shared Sub PrintValues(title As String, myList As IEnumerable)
        Console.Write("{0,10}: ", title)
        Dim sb As New StringBuilder()
        Dim s As String
        For Each s In  myList
            sb.AppendFormat("{0}, ", s)
        Next s
        sb.Remove(sb.Length - 2, 2)
        Console.WriteLine(sb)
    End Sub
End Class

Public Class ReverseStringComparer 
  Implements IComparer
    
     Function Compare(x As Object, y As Object) As Integer implements IComparer.Compare
        Dim s1 As String = CStr (x)
        Dim s2 As String = CStr (y)
        
        'negate the return value to get the reverse order
        Return - [String].Compare(s1, s2)
    
    End Function 'Compare
End Class

Megjegyzések

Warning

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, true) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, true) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, True) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Hasonlítsa össze az elérési utat a "fájl" névvel egy sorszámos összehasonlítással. Ehhez a megfelelő kód a következő:

static bool IsFileURI(String path)
{
    return (String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) == 0);
}

let isFileURI path =
    String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0

Shared Function IsFileURI(ByVal path As String) As Boolean
    If String.Compare(path, 0, "file:", 0, 5, StringComparison.OrdinalIgnoreCase) = 0 Then
        Return True
    Else
        Return False
    End If
End Function

Megjegyzések a hívókhoz

A karakterkészletek figyelmen kívül hagyható karaktereket tartalmaznak. A Compare(String, String) metódus nem veszi figyelembe az ilyen karaktereket, ha kulturális szempontból érzékeny összehasonlítást végez. Ha például a következő kód a .NET Framework 4-es vagy újabb verzióján fut, az "állat" és az "ani-mal" kultúraérzékeny összehasonlítása (puha kötőjel vagy U+00AD használatával) azt jelzi, hogy a két sztring egyenértékű.

string s1 = "ani\u00ADmal";
string s2 = "animal";

Console.WriteLine("Comparison of '{0}' and '{1}': {2}",
                s1, s2, String.Compare(s1, s2));

// The example displays the following output:
//       Comparison of 'ani-mal' and 'animal': 0

open System

let s1 = "ani\u00ADmal"
let s2 = "animal"

printfn $"Comparison of '{s1}' and '{s2}': {String.Compare(s1, s2)}"

// The example displays the following output:
//       Comparison of 'ani-mal' and 'animal': 0

Module Example
   Public Sub Main()
      Dim s1 As String = "ani" + ChrW(&h00AD) + "mal"
      Dim s2 As String = "animal"
      
      Console.WriteLine("Comparison of '{0}' and '{1}': {2}", 
                        s1, s2, String.Compare(s1, s2))
  End Sub
End Module
' The example displays the following output:
'       Comparison of 'ani-mal' and 'animal': 0

Lásd még

A következőre érvényes:

Visszajelzés

Hasznosnak találta ezt az oldalt?