String.Compare Metodo
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
Confronta due oggetti String specificati e restituisce un intero che ne indica la posizione relativa nell'ordinamento.
Overload
Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) |
Confronta le sottostringhe di due oggetti String specificati, usando le opzioni di confronto specificate e le informazioni specifiche delle impostazioni cultura per influenzare il confronto, e restituisce un intero che indica la relazione reciproca tra le due sottostringhe nell'ordinamento. |
Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) |
Confronta le sottostringhe di due oggetti String specificati, ignorando o rispettando la distinzione tra maiuscole e minuscole e usando le informazioni specifiche delle impostazioni cultura per influenzare il confronto, e restituisce un intero che ne indica la posizione relativa nell'ordinamento. |
Compare(String, Int32, String, Int32, Int32, StringComparison) |
Confronta sottostringhe di due oggetti String specificati usando le regole specificate e restituisce un intero che ne indica la posizione relativa nell'ordinamento. |
Compare(String, Int32, String, Int32, Int32, Boolean) |
Confronta le sottostringhe di due oggetti String specificati, ignorando o rispettando la distinzione tra maiuscole e minuscole, e restituisce un intero che ne indica la posizione relativa nell'ordinamento. |
Compare(String, Int32, String, Int32, Int32) |
Confronta le sottostringhe di due oggetti String specificati e restituisce un intero che indica la relativa posizione nell'ordinamento. |
Compare(String, String, CultureInfo, CompareOptions) |
Confronta due oggetti String specificati, usando le opzioni di confronto specificate e le informazioni specifiche delle impostazioni cultura per influenzare il confronto, e restituisce un intero che indica la relazione reciproca tra le due stringhe nell'ordinamento. |
Compare(String, String, Boolean, CultureInfo) |
Confronta due oggetti String specificati, ignorando o rispettando la distinzione tra maiuscole e minuscole e usando le informazioni specifiche delle impostazioni cultura per influenzare il confronto, e restituisce un intero che ne indica la posizione relativa nell'ordinamento. |
Compare(String, String, StringComparison) |
Confronta due oggetti String specificati usando le regole specificate e restituisce un intero che ne indica la posizione relativa nell'ordinamento. |
Compare(String, String, Boolean) |
Confronta due oggetti String specificati, ignorando o rispettando la distinzione tra maiuscole e minuscole, e restituisce un intero che ne indica la posizione relativa nell'ordinamento. |
Compare(String, String) |
Confronta due oggetti String specificati e restituisce un intero che ne indica la posizione relativa nell'ordinamento. |
Commenti
Tutti gli overload del metodo Compare restituiscono un intero con segno a 32 bit che indica la relazione lessicale tra i due termini del confronto.
Valore | Condizione |
---|---|
Minore di zero | La prima sottostringa precede la seconda sottostringa nell'ordine di ordinamento. |
Zero | Le sottostringhe si trovano nella stessa posizione nell'ordinamento oppure length è zero. |
Maggiore di zero | La prima sottostringa segue la seconda sottostringa nell'ordine di ordinamento. |
Avviso
Se possibile, è necessario chiamare un overload del Compare metodo che include un StringComparison parametro. Per altre informazioni, vedere Best Practices for Using Strings (Procedure consigliate per l'uso di stringhe).
Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)
- Origine:
- String.Comparison.cs
- Origine:
- String.Comparison.cs
- Origine:
- String.Comparison.cs
Confronta le sottostringhe di due oggetti String specificati, usando le opzioni di confronto specificate e le informazioni specifiche delle impostazioni cultura per influenzare il confronto, e restituisce un intero che indica la relazione reciproca tra le due sottostringhe nell'ordinamento.
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
Parametri
- strA
- String
Prima stringa da usare nel confronto.
- indexA
- Int32
Posizione iniziale della sottostringa all'interno di strA
.
- strB
- String
Seconda stringa da usare nel confronto.
- indexB
- Int32
Posizione iniziale della sottostringa all'interno di strB
.
- length
- Int32
Numero massimo di caratteri contenuti nelle sottostringhe da confrontare.
- culture
- CultureInfo
Oggetto che fornisce informazioni di confronto specifiche delle impostazioni cultura. Se culture
è null
, verranno usate le impostazioni cultura correnti.
- options
- CompareOptions
Opzioni da usare durante l'esecuzione del confronto (ad esempio, per ignorare la distinzione tra maiuscole e minuscole o i simboli).
Restituisce
Intero che indica la relazione lessicale tra le due sottostringhe, come illustrato nella tabella seguente.
Valore | Condizione |
---|---|
Minore di zero | La sottostringa in strA precede la sottostringa in strB nell'ordinamento.
|
Zero | Le sottostringhe si trovano nella stessa posizione nell'ordinamento oppure length è zero.
|
Maggiore di zero | La sottostringa in strA segue la sottostringa in strB nell'ordinamento.
|
Eccezioni
options
non è un valore di CompareOptions.
indexA
è maggiore di strA
.Length
.
-oppure-
indexB
è maggiore di strB
.Length
.
-oppure-
indexA
, indexB
o length
è negativo.
-oppure-
strA
o strB
è null
e length
è maggiore di zero.
Esempio
Nell'esempio seguente viene utilizzato il Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) metodo per confrontare i cognome di due persone. Vengono quindi elencati in ordine alfabetico.
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
Commenti
Le sottostringhe da confrontare iniziano in strA
corrispondenza della posizione indexA
e nella strB
posizione indexB
. La lunghezza della prima sottostringa è la lunghezza di strA
meno indexA
. La lunghezza della seconda sottostringa è la lunghezza di strB
meno indexB
.
Il numero di caratteri da confrontare è minore delle lunghezze delle due sottostringhe e length
. I indexA
parametri , indexB
e length
devono essere non negativi.
Il confronto usa il culture
parametro per ottenere informazioni specifiche delle impostazioni cultura, ad esempio le regole di maiuscole e minuscole e l'ordine alfabetico dei singoli caratteri. Ad esempio, una determinata cultura può specificare che determinate combinazioni di caratteri vengano considerate come un singolo carattere, che i caratteri maiuscoli e minuscoli vengano confrontati in un modo specifico o che l'ordinamento di un carattere dipende dai caratteri che lo precedono o seguono.
Attenzione
Il Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) metodo è progettato principalmente per l'uso nelle operazioni di ordinamento o di alfabetizzazione. Non deve essere usato quando lo scopo principale della chiamata al metodo consiste nel determinare se due sottostringhe sono equivalenti, ovvero quando lo scopo della chiamata al metodo consiste nel testare un valore restituito pari a zero. Per determinare se due stringhe sono equivalenti, chiamare il Equals metodo .
Uno o entrambi gli elementi strA
e strB
possono essere null
. Per definizione, qualsiasi stringa, incluso String.Empty, confronta un riferimento null maggiore di un riferimento Null e due riferimenti Null vengono confrontati tra loro.
Il confronto può essere ulteriormente specificato dal options
parametro , costituito da uno o più membri dell'enumerazione System.Globalization.CompareOptions . Tuttavia, poiché lo scopo di questo metodo è eseguire un confronto di stringhe sensibili alle impostazioni cultura, i CompareOptions.Ordinal valori e CompareOptions.OrdinalIgnoreCase non hanno alcun effetto.
Il confronto termina quando viene individuata una disuguaglianza o quando sono state confrontate entrambe le sottostringhe. Tuttavia, se le due stringhe confrontano uguale alla fine di una stringa e l'altra contiene caratteri rimanenti, la stringa con i caratteri rimanenti viene considerata maggiore. Il valore restituito è il risultato dell'ultimo confronto eseguito.
Note per i chiamanti
I set di caratteri includono caratteri ignorabili. Il Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) metodo non considera questi caratteri quando esegue un confronto linguistico o sensibile alle impostazioni cultura. Per riconoscere i caratteri ignorabili nel confronto, specificare un valore di Ordinal o OrdinalIgnoreCase per il options
parametro .
Vedi anche
Si applica a
Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)
- Origine:
- String.Comparison.cs
- Origine:
- String.Comparison.cs
- Origine:
- String.Comparison.cs
Confronta le sottostringhe di due oggetti String specificati, ignorando o rispettando la distinzione tra maiuscole e minuscole e usando le informazioni specifiche delle impostazioni cultura per influenzare il confronto, e restituisce un intero che ne indica la posizione relativa nell'ordinamento.
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
Parametri
- strA
- String
Prima stringa da usare nel confronto.
- indexA
- Int32
Posizione della sottostringa all'interno di strA
.
- strB
- String
Seconda stringa da usare nel confronto.
- indexB
- Int32
Posizione della sottostringa all'interno di strB
.
- length
- Int32
Numero massimo di caratteri contenuti nelle sottostringhe da confrontare.
- ignoreCase
- Boolean
true
per ignorare la distinzione tra maiuscole e minuscole durante il confronto; in caso contrario, false
.
- culture
- CultureInfo
Oggetto che fornisce informazioni di confronto specifiche delle impostazioni cultura. Se culture
è null
, verranno usate le impostazioni cultura correnti.
Restituisce
Intero che indica la relazione lessicale tra i due termini di confronto.
Valore | Condizione |
---|---|
Minore di zero | La sottostringa in strA precede la sottostringa in strB nell'ordinamento.
|
Zero | Le sottostringhe si trovano nella stessa posizione nell'ordinamento oppure length è zero.
|
Maggiore di zero | La sottostringa in strA segue la sottostringa in strB nell'ordinamento.
|
Eccezioni
indexA
è maggiore di strA
Length.
-oppure-
indexB
è maggiore di strB
Length.
-oppure-
indexA
, indexB
o length
è negativo.
-oppure-
strA
o strB
è null
e length
è maggiore di zero.
Esempio
Nell'esempio seguente vengono confrontate due sottostringhe usando impostazioni cultura diverse e viene ignorata la distinzione tra maiuscole e minuscole delle sottostringhe. La scelta delle impostazioni cultura influisce sul modo in cui viene confrontata la lettera "I".
// Sample for String::Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)
using namespace System;
using namespace System::Globalization;
int 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, gcnew CultureInfo( "tr-TR" ) );
str = ((result < 0) ? "less than" : ((result > 0) ? (String^)"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) ? (String^)"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)
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'.
'
Commenti
Le sottostringhe da confrontare iniziano in strA
in e indexA
in strB
in in .indexB
Sia che indexA
sono in base zero, ovvero il primo carattere in e strB
si trova nella strA
posizione zero, non nella posizione indexB
1. La lunghezza della prima sottostringa è uguale alla lunghezza di strA
meno indexA
uno. La lunghezza della seconda sottostringa è uguale alla lunghezza di strB
meno indexB
uno.
Il numero di caratteri da confrontare è minore delle lunghezze delle due sottostringhe e length
. I indexA
parametri , indexB
e length
devono essere non negativi.
Il confronto usa il culture
parametro per ottenere informazioni specifiche delle impostazioni cultura, ad esempio le regole di maiuscole e minuscole e l'ordine alfabetico dei singoli caratteri. Ad esempio, le impostazioni cultura potrebbero specificare che determinate combinazioni di caratteri vengano considerate come un singolo carattere o caratteri maiuscoli e minuscoli vengano confrontate in un modo specifico o che l'ordinamento di un carattere dipende dai caratteri che lo precedono o lo seguono.
Il confronto viene eseguito usando le regole di ordinamento delle parole. Per altre informazioni sugli ordinali di parole, stringhe e ordinali, vedere System.Globalization.CompareOptions.
Uno o entrambi i comparand possono essere null
. Per definizione, qualsiasi stringa, inclusa la stringa vuota (""), confronta un riferimento maggiore di un riferimento Null; e due riferimenti Null vengono confrontati tra loro.
Il confronto termina quando viene individuata una disuguaglianza o quando sono state confrontate entrambe le sottostringhe. Tuttavia, se le due stringhe confrontano uguale alla fine di una stringa e l'altra contiene caratteri rimanenti, la stringa con i caratteri rimanenti viene considerata maggiore. Il valore restituito è il risultato dell'ultimo confronto eseguito.
I risultati imprevisti possono verificarsi quando i confronti sono interessati da regole di maiuscole e minuscole specifiche delle impostazioni cultura. Ad esempio, in turco, l'esempio seguente restituisce i risultati errati perché il file system in turco non usa regole di maiuscole e minuscole linguistiche per la lettera "i" in "file".
static bool IsFileURI(String^ path)
{
return (String::Compare(path, 0, "file:", 0, 5, true) == 0);
}
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
Confrontare il nome del percorso con "file" usando un confronto ordinale. Il codice corretto per eseguire questa operazione è il seguente:
static bool IsFileURI(String^ path)
{
return (String::Compare(path, 0, "file:", 0, 5, StringComparison::OrdinalIgnoreCase) == 0);
}
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
Note per i chiamanti
I set di caratteri includono caratteri ignorabili. Il Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) metodo non considera questi caratteri quando esegue un confronto linguistico o sensibile alle impostazioni cultura. Per riconoscere i caratteri ignorabili nel confronto, chiamare il Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) metodo e specificare un valore di Ordinal o OrdinalIgnoreCase per il options
parametro .
Vedi anche
Si applica a
Compare(String, Int32, String, Int32, Int32, StringComparison)
- Origine:
- String.Comparison.cs
- Origine:
- String.Comparison.cs
- Origine:
- String.Comparison.cs
Confronta sottostringhe di due oggetti String specificati usando le regole specificate e restituisce un intero che ne indica la posizione relativa nell'ordinamento.
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
Parametri
- strA
- String
Prima stringa da usare nel confronto.
- indexA
- Int32
Posizione della sottostringa all'interno di strA
.
- strB
- String
Seconda stringa da usare nel confronto.
- indexB
- Int32
Posizione della sottostringa all'interno di strB
.
- length
- Int32
Numero massimo di caratteri contenuti nelle sottostringhe da confrontare.
- comparisonType
- StringComparison
Uno dei valori di enumerazione che specifica le regole da usare per il confronto.
Restituisce
Intero con segno a 32 bit che indica la relazione lessicale tra i due termini di confronto.
Valore | Condizione |
---|---|
Minore di zero | La sottostringa in strA precede la sottostringa in strB nell'ordinamento.
|
Zero | Le sottostringhe si trovano nella stessa posizione nell'ordinamento oppure il parametro length è zero.
|
Maggiore di zero | La sottostringa in strA segue la sottostringa in strB nell'ordinamento.
|
Eccezioni
indexA
è maggiore di strA
Length.
-oppure-
indexB
è maggiore di strB
Length.
-oppure-
indexA
, indexB
o length
è negativo.
-oppure-
indexA
o indexB
è null
e length
è maggiore di zero.
comparisonType
non è un valore di StringComparison.
Esempio
Nell'esempio seguente vengono confrontate due sottostringhe.
// Sample for String::Compare(String, Int32, String, Int32, Int32)
using namespace System;
int main()
{
// 0123456
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) ? (String^)"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'.
*/
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'.
'
Commenti
Le sottostringhe da confrontare iniziano da e indexA
in strA
strB
all'indirizzo indexB
. Sia che indexA
sono in base zero, ovvero il primo carattere in e strB
si trova nella strA
posizione zero, non nella posizione indexB
1. La lunghezza della prima sottostringa è uguale alla lunghezza di strA
meno indexA
uno. La lunghezza della seconda sottostringa è uguale alla lunghezza di strB
meno indexB
uno.
Il numero di caratteri da confrontare è minore delle lunghezze delle due sottostringhe e length
. I indexA
parametri , indexB
e length
devono essere non negativi.
Il comparisonType
parametro indica se il confronto deve usare le impostazioni cultura correnti o invarianti, rispettare o ignorare la distinzione tra maiuscole e minuscole oppure usare le regole di ordinamento non sensibili alle impostazioni cultura o ordinali (senza distinzione tra impostazioni cultura).
Uno o entrambi i comparand possono essere null
. Per definizione, qualsiasi stringa, inclusa la stringa vuota (""), confronta un riferimento maggiore di un riferimento Null; e due riferimenti Null vengono confrontati tra loro.
Il confronto termina quando viene individuata una disuguaglianza o quando sono state confrontate entrambe le sottostringhe. Tuttavia, se le due stringhe confrontano uguale alla fine di una stringa e l'altra contiene caratteri rimanenti, la stringa con i caratteri rimanenti viene considerata maggiore. Il valore restituito è il risultato dell'ultimo confronto eseguito.
I risultati imprevisti possono verificarsi quando i confronti sono interessati da regole di maiuscole e minuscole specifiche delle impostazioni cultura. Ad esempio, in turco, l'esempio seguente restituisce i risultati errati perché il file system in turco non usa regole di maiuscole e minuscole linguistiche per la lettera "i" in "file".
static bool IsFileURI(String^ path)
{
return (String::Compare(path, 0, "file:", 0, 5, true) == 0);
}
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
Confrontare il nome del percorso con "file" usando un confronto ordinale. Il codice corretto per eseguire questa operazione è il seguente:
static bool IsFileURI(String^ path)
{
return (String::Compare(path, 0, "file:", 0, 5, StringComparison::OrdinalIgnoreCase) == 0);
}
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
Note per i chiamanti
I set di caratteri includono caratteri ignorabili. Il Compare(String, Int32, String, Int32, Int32, StringComparison) metodo non considera questi caratteri quando esegue un confronto linguistico o sensibile alle impostazioni cultura. Per riconoscere i caratteri ignorabili nel confronto, specificare un valore di Ordinal o OrdinalIgnoreCase per il comparisonType
parametro .
Vedi anche
Si applica a
Compare(String, Int32, String, Int32, Int32, Boolean)
- Origine:
- String.Comparison.cs
- Origine:
- String.Comparison.cs
- Origine:
- String.Comparison.cs
Confronta le sottostringhe di due oggetti String specificati, ignorando o rispettando la distinzione tra maiuscole e minuscole, e restituisce un intero che ne indica la posizione relativa nell'ordinamento.
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
Parametri
- strA
- String
Prima stringa da usare nel confronto.
- indexA
- Int32
Posizione della sottostringa all'interno di strA
.
- strB
- String
Seconda stringa da usare nel confronto.
- indexB
- Int32
Posizione della sottostringa all'interno di strB
.
- length
- Int32
Numero massimo di caratteri contenuti nelle sottostringhe da confrontare.
- ignoreCase
- Boolean
true
per ignorare la distinzione tra maiuscole e minuscole durante il confronto; in caso contrario, false
.
Restituisce
Intero con segno a 32 bit che indica la relazione lessicale tra i due termini di confronto.
Valore | Condizione |
---|---|
Minore di zero | La sottostringa in strA precede la sottostringa in strB nell'ordinamento.
|
Zero | Le sottostringhe si trovano nella stessa posizione nell'ordinamento oppure length è zero.
|
Maggiore di zero | La sottostringa in strA segue la sottostringa in strB nell'ordinamento.
|
Eccezioni
indexA
è maggiore di strA
Length.
-oppure-
indexB
è maggiore di strB
Length.
-oppure-
indexA
, indexB
o length
è negativo.
-oppure-
indexA
o indexB
è null
e length
è maggiore di zero.
Esempio
L'esempio seguente esegue due confronti di due sottostringhe che differiscono solo nel caso. Il primo confronto ignora la distinzione tra maiuscole e minuscole e il secondo confronto prende in considerazione la distinzione tra maiuscole e minuscole.
// Sample for String::Compare(String, Int32, String, Int32, Int32, Boolean)
using namespace System;
int 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:" );
result = String::Compare( str1, 2, str2, 2, 2, true );
str = ((result < 0) ? "less than" : ((result > 0) ? (String^)"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) ? (String^)"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'.
*/
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'.
'
Commenti
Le sottostringhe da confrontare iniziano in strA
in e indexA
in strB
in in .indexB
Sia che indexA
sono in base zero, ovvero il primo carattere in e strB
si trova nella strA
posizione indexB
zero. La lunghezza della prima sottostringa è uguale alla lunghezza di strA
meno indexA
uno. La lunghezza della seconda sottostringa è uguale alla lunghezza di strB
meno indexB
uno.
Il numero di caratteri da confrontare è minore delle lunghezze delle due sottostringhe e length
. I indexA
parametri , indexB
e length
devono essere non negativi.
Il confronto usa le impostazioni cultura correnti per ottenere informazioni specifiche delle impostazioni cultura, ad esempio le regole di maiuscole e minuscole e l'ordine alfabetico dei singoli caratteri. Ad esempio, le impostazioni cultura potrebbero specificare che determinate combinazioni di caratteri vengano considerate come un singolo carattere o caratteri maiuscoli e minuscoli vengano confrontate in un modo specifico o che l'ordinamento di un carattere dipende dai caratteri che lo precedono o lo seguono.
Il confronto viene eseguito usando le regole di ordinamento delle parole. Per altre informazioni sugli ordinali di parole, stringhe e ordinali, vedere System.Globalization.CompareOptions.
Avviso
Quando si confrontano stringhe, è necessario chiamare il Compare(String, Int32, String, Int32, Int32, StringComparison) metodo , che richiede di specificare in modo esplicito il tipo di confronto tra stringhe utilizzato dal metodo. Per altre informazioni, vedere Best Practices for Using Strings (Procedure consigliate per l'uso di stringhe).
Uno o entrambi i comparand possono essere null
. Per definizione, qualsiasi stringa, inclusa la stringa vuota (""), confronta un riferimento maggiore di un riferimento Null; e due riferimenti Null vengono confrontati tra loro.
Il confronto termina quando viene individuata una disuguaglianza o quando sono state confrontate entrambe le sottostringhe. Tuttavia, se le due stringhe confrontano uguale alla fine di una stringa e l'altra contiene caratteri rimanenti, la stringa con i caratteri rimanenti viene considerata maggiore. Il valore restituito è il risultato dell'ultimo confronto eseguito.
I risultati imprevisti possono verificarsi quando i confronti sono interessati da regole di maiuscole e minuscole specifiche delle impostazioni cultura. Ad esempio, in turco, l'esempio seguente restituisce i risultati errati perché il file system in turco non usa regole di maiuscole e minuscole linguistiche per la lettera "i" in "file".
static bool IsFileURI(String^ path)
{
return (String::Compare(path, 0, "file:", 0, 5, true) == 0);
}
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
Il nome del percorso deve essere confrontato in modo invariante. Il codice corretto per eseguire questa operazione è il seguente.
static bool IsFileURI(String^ path)
{
return (String::Compare(path, 0, "file:", 0, 5, StringComparison::OrdinalIgnoreCase) == 0);
}
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
Note per i chiamanti
I set di caratteri includono caratteri ignorabili. Il Compare(String, Int32, String, Int32, Int32, Boolean) metodo non considera questi caratteri quando esegue un confronto linguistico o sensibile alle impostazioni cultura. Per riconoscere i caratteri ignorabili nel confronto, chiamare il Compare(String, Int32, String, Int32, Int32, StringComparison) metodo e specificare un valore di Ordinal o OrdinalIgnoreCase per il comparisonType
parametro .
Vedi anche
Si applica a
Compare(String, Int32, String, Int32, Int32)
- Origine:
- String.Comparison.cs
- Origine:
- String.Comparison.cs
- Origine:
- String.Comparison.cs
Confronta le sottostringhe di due oggetti String specificati e restituisce un intero che indica la relativa posizione nell'ordinamento.
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
Parametri
- strA
- String
Prima stringa da usare nel confronto.
- indexA
- Int32
Posizione della sottostringa all'interno di strA
.
- strB
- String
Seconda stringa da usare nel confronto.
- indexB
- Int32
Posizione della sottostringa all'interno di strB
.
- length
- Int32
Numero massimo di caratteri contenuti nelle sottostringhe da confrontare.
Restituisce
Intero con segno a 32 bit che indica la relazione lessicale tra i due termini del confronto.
Valore | Condizione |
---|---|
Minore di zero | La sottostringa in strA precede la sottostringa in strB nell'ordinamento.
|
Zero | Le sottostringhe si trovano nella stessa posizione nell'ordinamento oppure length è zero.
|
Maggiore di zero | La sottostringa in strA segue la sottostringa in strB nell'ordinamento.
|
Eccezioni
indexA
è maggiore di strA
Length.
-oppure-
indexB
è maggiore di strB
Length.
-oppure-
indexA
, indexB
o length
è negativo.
-oppure-
indexA
o indexB
è null
e length
è maggiore di zero.
Esempio
Nell'esempio seguente vengono confrontate due sottostringhe.
// Sample for String::Compare(String, Int32, String, Int32, Int32)
using namespace System;
int main()
{
// 0123456
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) ? (String^)"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'.
*/
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'.
'
Commenti
Le sottostringhe da confrontare iniziano da e indexA
in strA
strB
all'indirizzo indexB
. Sia che indexA
sono in base zero, ovvero il primo carattere in e strB
si trova nella strA
posizione indexB
zero. La lunghezza della prima sottostringa è uguale alla lunghezza di strA
meno indexA
uno. La lunghezza della seconda sottostringa è uguale alla lunghezza di strB
meno indexB
uno.
Il numero di caratteri da confrontare è minore delle lunghezze delle due sottostringhe e length
. I indexA
parametri , indexB
e length
devono essere non negativi.
Il confronto usa le impostazioni cultura correnti per ottenere informazioni specifiche delle impostazioni cultura, ad esempio le regole di maiuscole e minuscole e l'ordine alfabetico dei singoli caratteri. Ad esempio, le impostazioni cultura potrebbero specificare che determinate combinazioni di caratteri vengano considerate come un singolo carattere o caratteri maiuscoli e minuscoli vengano confrontate in un modo specifico o che l'ordinamento di un carattere dipende dai caratteri che lo precedono o lo seguono.
Il confronto viene eseguito usando le regole di ordinamento delle parole. Per altre informazioni sugli ordinali di parole, stringhe e ordinali, vedere System.Globalization.CompareOptions.
Avviso
Quando si confrontano stringhe, è necessario chiamare il Compare(String, Int32, String, Int32, Int32, StringComparison) metodo , che richiede di specificare in modo esplicito il tipo di confronto tra stringhe utilizzato dal metodo. Per altre informazioni, vedere Best Practices for Using Strings (Procedure consigliate per l'uso di stringhe).
Uno o entrambi i comparand possono essere null
. Per definizione, qualsiasi stringa, inclusa la stringa vuota (""), confronta un riferimento maggiore di un riferimento Null; e due riferimenti Null vengono confrontati tra loro.
Il confronto termina quando viene individuata una disuguaglianza o quando sono state confrontate entrambe le sottostringhe. Tuttavia, se le due stringhe confrontano uguale alla fine di una stringa e l'altra contiene caratteri rimanenti, la stringa con i caratteri rimanenti viene considerata maggiore. Il valore restituito è il risultato dell'ultimo confronto eseguito.
I risultati imprevisti possono verificarsi quando i confronti sono interessati da regole di maiuscole e minuscole specifiche delle impostazioni cultura. Ad esempio, in turco, l'esempio seguente restituisce i risultati errati perché il file system in turco non usa regole di maiuscole e minuscole linguistiche per la lettera "i" in "file".
static bool IsFileURI(String^ path)
{
return (String::Compare(path, 0, "file:", 0, 5, true) == 0);
}
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
Confrontare il nome del percorso con "file" usando un confronto ordinale. Il codice corretto per eseguire questa operazione è il seguente:
static bool IsFileURI(String^ path)
{
return (String::Compare(path, 0, "file:", 0, 5, StringComparison::OrdinalIgnoreCase) == 0);
}
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
Note per i chiamanti
I set di caratteri includono caratteri ignorabili. Il Compare(String, Int32, String, Int32, Int32) metodo non considera questi caratteri quando esegue un confronto linguistico o sensibile alle impostazioni cultura. Per riconoscere i caratteri ignorabili nel confronto, chiamare il Compare(String, Int32, String, Int32, Int32, StringComparison) metodo e specificare un valore di Ordinal o OrdinalIgnoreCase per il comparisonType
parametro .
Vedi anche
Si applica a
Compare(String, String, CultureInfo, CompareOptions)
- Origine:
- String.Comparison.cs
- Origine:
- String.Comparison.cs
- Origine:
- String.Comparison.cs
Confronta due oggetti String specificati, usando le opzioni di confronto specificate e le informazioni specifiche delle impostazioni cultura per influenzare il confronto, e restituisce un intero che indica la relazione reciproca tra le due stringhe nell'ordinamento.
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
Parametri
- strA
- String
Prima stringa da confrontare.
- strB
- String
Seconda stringa da confrontare.
- culture
- CultureInfo
Impostazioni cultura che forniscono informazioni di confronto specifiche delle impostazioni cultura. Se culture
è null
, verranno usate le impostazioni cultura correnti.
- options
- CompareOptions
Opzioni da usare durante l'esecuzione del confronto (ad esempio, per ignorare la distinzione tra maiuscole e minuscole o i simboli).
Restituisce
Intero con segno a 32 bit che indica la relazione lessicale tra strA
e strB
, come illustrato nella tabella seguente.
Valore | Condizione |
---|---|
Minore di zero | strA precede strB nell'ordinamento.
|
Zero | strA si trova nella stessa posizione di strB nell'ordinamento.
|
Maggiore di zero | strA segue strB nell'ordinamento.
|
Eccezioni
options
non è un valore di CompareOptions.
Esempio
Nell'esempio seguente vengono confrontate due stringhe in tre modi diversi: Usare il confronto linguistico per le impostazioni cultura en-US; utilizzando il confronto linguistico con distinzione tra maiuscole e minuscole per le impostazioni cultura en-US; e utilizzando un confronto ordinale. Illustra in che modo i tre metodi di confronto producono tre risultati diversi.
using namespace System;
using namespace System::Globalization;
public ref class Example
{
public:
static void Main()
{
String^ string1 = "brother";
String^ string2 = "Brother";
String^ relation;
int result;
// Cultural (linguistic) comparison.
result = String::Compare(string1, string2, gcnew 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, gcnew 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);
}
};
int main()
{
Example::Main();
}
// The example produces the following output:
// 'brother' comes before 'Brother'.
// 'brother' is the same as 'Brother'.
// 'brother' comes after 'Brother'.
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'.
Commenti
Il confronto usa il culture
parametro per ottenere informazioni specifiche delle impostazioni cultura, ad esempio le regole di maiuscole e minuscole e l'ordine alfabetico dei singoli caratteri. Ad esempio, una determinata cultura può specificare che determinate combinazioni di caratteri vengano considerate come un singolo carattere, che i caratteri maiuscoli e minuscoli vengano confrontati in un modo specifico o che l'ordinamento di un carattere dipende dai caratteri che lo precedono o seguono.
Attenzione
Il Compare(String, String, CultureInfo, CompareOptions) metodo è progettato principalmente per l'uso nelle operazioni di ordinamento o di alfabetizzazione. Non deve essere usato quando lo scopo principale della chiamata al metodo consiste nel determinare se due stringhe sono equivalenti, ovvero quando lo scopo della chiamata al metodo consiste nel testare un valore restituito pari a zero. Per determinare se due stringhe sono equivalenti, chiamare il Equals metodo .
Il confronto può essere ulteriormente specificato dal options
parametro , costituito da uno o più membri dell'enumerazione CompareOptions . Tuttavia, poiché lo scopo di questo metodo è eseguire un confronto di stringhe sensibili alle impostazioni cultura, i CompareOptions.Ordinal valori e CompareOptions.OrdinalIgnoreCase non hanno alcun effetto.
Entrambi i comparandi possono essere null
. Per definizione, qualsiasi stringa, incluso String.Empty, confronta un riferimento null maggiore di un riferimento Null e due riferimenti Null vengono confrontati tra loro.
Il confronto termina quando viene individuata una disuguaglianza o vengono confrontate entrambe le stringhe. Tuttavia, se le due stringhe confrontano uguale alla fine di una stringa e l'altra contiene caratteri rimanenti, la stringa con i caratteri rimanenti viene considerata maggiore.
Note per i chiamanti
I set di caratteri includono caratteri ignorabili, ovvero caratteri che non sono considerati durante l'esecuzione di un confronto linguistico o dipendente dalle impostazioni cultura. Il Compare(String, String, CultureInfo, CompareOptions) metodo non considera tali caratteri quando esegue un confronto con distinzione tra impostazioni cultura. Per riconoscere i caratteri ignorabili nel confronto, specificare un valore di Ordinal o OrdinalIgnoreCase per il options
parametro .
Vedi anche
Si applica a
Compare(String, String, Boolean, CultureInfo)
- Origine:
- String.Comparison.cs
- Origine:
- String.Comparison.cs
- Origine:
- String.Comparison.cs
Confronta due oggetti String specificati, ignorando o rispettando la distinzione tra maiuscole e minuscole e usando le informazioni specifiche delle impostazioni cultura per influenzare il confronto, e restituisce un intero che ne indica la posizione relativa nell'ordinamento.
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
Parametri
- strA
- String
Prima stringa da confrontare.
- strB
- String
Seconda stringa da confrontare.
- ignoreCase
- Boolean
true
per ignorare la distinzione tra maiuscole e minuscole durante il confronto; in caso contrario, false
.
- culture
- CultureInfo
Oggetto che fornisce informazioni di confronto specifiche delle impostazioni cultura. Se culture
è null
, verranno usate le impostazioni cultura correnti.
Restituisce
Intero con segno a 32 bit che indica la relazione lessicale tra i due termini di confronto.
Valore | Condizione |
---|---|
Minore di zero | strA precede strB nell'ordinamento.
|
Zero | strA si trova nella stessa posizione di strB nell'ordinamento.
|
Maggiore di zero | strA segue strB nell'ordinamento.
|
Esempio
Nell'esempio seguente viene illustrato come le impostazioni cultura possono influire su un confronto. Nella cultura ceca - Repubblica Ceca "ch" è un singolo carattere maggiore di "d". Tuttavia, in inglese - Stati Uniti impostazioni cultura, "ch" è costituito da due caratteri e "c" è minore di "d".
using namespace System;
using namespace System::Globalization;
String^ symbol( int r )
{
String^ s = "=";
if ( r < 0 )
s = "<";
else
if ( r > 0 )
s = ">";
return s;
}
int main()
{
String^ str1 = "change";
String^ str2 = "dollar";
String^ relation = nullptr;
relation = symbol( String::Compare( str1, str2, false, gcnew CultureInfo( "en-US" ) ) );
Console::WriteLine( "For en-US: {0} {1} {2}", str1, relation, str2 );
relation = symbol( String::Compare( str1, str2, false, gcnew CultureInfo( "cs-CZ" ) ) );
Console::WriteLine( "For cs-CZ: {0} {1} {2}", str1, relation, str2 );
}
/*
This example produces the following results.
For en-US: change < dollar
For cs-CZ: change > dollar
*/
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
'
Commenti
Il confronto usa il culture
parametro per ottenere informazioni specifiche delle impostazioni cultura, ad esempio le regole di maiuscole e minuscole e l'ordine alfabetico dei singoli caratteri. Ad esempio, le impostazioni cultura potrebbero specificare che determinate combinazioni di caratteri vengano considerate come un singolo carattere o caratteri maiuscoli e minuscoli vengano confrontate in un modo specifico o che l'ordinamento di un carattere dipende dai caratteri che lo precedono o lo seguono.
Il confronto viene eseguito usando le regole di ordinamento delle parole. Per altre informazioni sugli ordinali di parole, stringhe e ordinali, vedere System.Globalization.CompareOptions.
Uno o entrambi i comparand possono essere null
. Per definizione, qualsiasi stringa, inclusa la stringa vuota (""), confronta un riferimento maggiore di un riferimento Null; e due riferimenti Null vengono confrontati tra loro.
Il confronto termina quando viene individuata una disuguaglianza o vengono confrontate entrambe le stringhe. Tuttavia, se le due stringhe confrontano uguale alla fine di una stringa e l'altra contiene caratteri rimanenti, la stringa con i caratteri rimanenti viene considerata maggiore. Il valore restituito è il risultato dell'ultimo confronto eseguito.
I risultati imprevisti possono verificarsi quando i confronti sono interessati da regole di maiuscole e minuscole specifiche delle impostazioni cultura. Ad esempio, in turco, l'esempio seguente restituisce i risultati errati perché il file system in turco non usa regole di maiuscole e minuscole linguistiche per la lettera "i" in "file".
static bool IsFileURI(String^ path)
{
return (String::Compare(path, 0, "file:", 0, 5, true) == 0);
}
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
Confrontare il nome del percorso con "file" usando un confronto ordinale. Il codice corretto per eseguire questa operazione è il seguente:
static bool IsFileURI(String^ path)
{
return (String::Compare(path, 0, "file:", 0, 5, StringComparison::OrdinalIgnoreCase) == 0);
}
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
Note per i chiamanti
I set di caratteri includono caratteri ignorabili. Il Compare(String, String, Boolean, CultureInfo) metodo non considera tali caratteri quando esegue un confronto con distinzione tra impostazioni cultura. Ad esempio, se il codice seguente viene eseguito in .NET Framework 4 o versione successiva, un confronto senza distinzione tra maiuscole e minuscole di "animal" con "Ani-mal" (usando un trattino morbido o U+00AD) usando le impostazioni cultura invarianti indica che le due stringhe sono equivalenti.
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
Per riconoscere i caratteri ignorabili in un confronto tra stringhe, chiamare il Compare(String, String, CultureInfo, CompareOptions) metodo e specificare un valore di Ordinal o OrdinalIgnoreCase per il options
parametro .
Vedi anche
- Int32
- CompareOrdinal(String, String)
- CompareTo(Object)
- IsPrefix(String, String, CompareOptions)
- Boolean
Si applica a
Compare(String, String, StringComparison)
- Origine:
- String.Comparison.cs
- Origine:
- String.Comparison.cs
- Origine:
- String.Comparison.cs
Confronta due oggetti String specificati usando le regole specificate e restituisce un intero che ne indica la posizione relativa nell'ordinamento.
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
Parametri
- strA
- String
Prima stringa da confrontare.
- strB
- String
Seconda stringa da confrontare.
- comparisonType
- StringComparison
Uno dei valori di enumerazione che specifica le regole da usare per il confronto.
Restituisce
Intero con segno a 32 bit che indica la relazione lessicale tra i due termini di confronto.
Valore | Condizione |
---|---|
Minore di zero | strA precede strB nell'ordinamento.
|
Zero | strA si trova nella stessa posizione di strB nell'ordinamento.
|
Maggiore di zero | strA segue strB nell'ordinamento.
|
Eccezioni
comparisonType
non è un valore di StringComparison.
StringComparison non è supportato.
Esempio
Nell'esempio seguente vengono confrontate tre versioni della lettera "I". I risultati sono interessati dalla scelta delle impostazioni cultura, dal fatto che la distinzione tra maiuscole e minuscole venga ignorata e dal fatto che venga eseguito un confronto ordinale.
// This example demonstrates the
// System.String.Compare(String, String, StringComparison) method.
using namespace System;
using namespace System::Threading;
void Test(int testStringIndex, int searchStringIndex,
StringComparison comparison, array<String^>^ testI,
array<String^>^ testNames)
{
String^ resultFormat = "{0} is {1} {2}";
String^ resultString = "equal to";
int comparisonValue = 0;
comparisonValue = String::Compare(testI[testStringIndex],
testI[searchStringIndex], comparison);
if (comparisonValue < 0)
{
resultString = "less than";
}
else if (comparisonValue > 0)
{
resultString = "greater than";
}
Console::WriteLine(resultFormat, testNames[testStringIndex], resultString,
testNames[searchStringIndex]);
}
int main()
{
String^ introMessage =
"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.)
array<String^>^ letterVariation = gcnew array<String^>(3);
// LATIN SMALL LETTER I (U+0069)
letterVariation[0] = "i";
// LATIN SMALL LETTER DOTLESS I (U+0131)
letterVariation[1] = L"\u0131";
// LATIN CAPITAL LETTER I (U+0049)
letterVariation[2] = "I";
array<String^>^ unicodeNames = {
"LATIN SMALL LETTER I (U+0069)",
"LATIN SMALL LETTER DOTLESS I (U+0131)",
"LATIN CAPITAL LETTER I (U+0049)"};
array<StringComparison>^ comparisonValues = {
StringComparison::CurrentCulture,
StringComparison::CurrentCultureIgnoreCase,
StringComparison::InvariantCulture,
StringComparison::InvariantCultureIgnoreCase,
StringComparison::Ordinal,
StringComparison::OrdinalIgnoreCase};
Console::Clear();
Console::WriteLine(introMessage);
// Display the current culture because the culture-specific comparisons
// can produce different results with different cultures.
Console::WriteLine("The current culture is {0}.{1}",
Thread::CurrentThread->CurrentCulture->Name, Environment::NewLine);
// Determine the relative sort order of three versions of the letter I.
for each (StringComparison stringCmp in comparisonValues)
{
Console::WriteLine("StringComparison.{0}:", stringCmp);
// LATIN SMALL LETTER I (U+0069) : LATIN SMALL LETTER DOTLESS I
// (U+0131)
Test(0, 1, stringCmp, letterVariation, unicodeNames);
// LATIN SMALL LETTER I (U+0069) : LATIN CAPITAL LETTER I (U+0049)
Test(0, 2, stringCmp, letterVariation, unicodeNames);
// LATIN SMALL LETTER DOTLESS I (U+0131) : LATIN CAPITAL LETTER I
// (U+0049)
Test(1, 2, stringCmp, letterVariation, unicodeNames);
Console::WriteLine();
}
}
/*
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.
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)
'
Commenti
Il comparisonType
parametro indica se il confronto deve usare le impostazioni cultura correnti o invarianti, rispettare o ignorare la distinzione tra maiuscole e minuscole oppure usare le regole di ordinamento non sensibili alle impostazioni cultura o ordinali (senza distinzione tra impostazioni cultura).
Uno o entrambi i comparand possono essere null
. Per definizione, qualsiasi stringa, inclusa la stringa vuota (""), confronta un riferimento maggiore di un riferimento Null; e due riferimenti Null vengono confrontati tra loro.
Il confronto termina quando viene individuata una disuguaglianza o vengono confrontate entrambe le stringhe. Tuttavia, se le due stringhe confrontano uguale alla fine di una stringa e l'altra contiene caratteri rimanenti, la stringa con i caratteri rimanenti viene considerata maggiore. Il valore restituito è il risultato dell'ultimo confronto eseguito.
I risultati imprevisti possono verificarsi quando i confronti sono interessati da regole di maiuscole e minuscole specifiche delle impostazioni cultura. Ad esempio, in turco, l'esempio seguente restituisce i risultati errati perché il file system in turco non usa regole di maiuscole e minuscole linguistiche per la lettera "i" in "file".
static bool IsFileURI(String^ path)
{
return (String::Compare(path, 0, "file:", 0, 5, true) == 0);
}
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
Confrontare il nome del percorso con "file" usando un confronto ordinale. Il codice corretto per eseguire questa operazione è il seguente:
static bool IsFileURI(String^ path)
{
return (String::Compare(path, 0, "file:", 0, 5, StringComparison::OrdinalIgnoreCase) == 0);
}
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
Note per i chiamanti
I set di caratteri includono caratteri ignorabili. Il Compare(String, String, StringComparison) metodo non considera tali caratteri quando esegue un confronto con distinzione tra impostazioni cultura. Per riconoscere i caratteri ignorabili nel confronto, specificare un valore di Ordinal o OrdinalIgnoreCase per il comparisonType
parametro .
Vedi anche
Si applica a
Compare(String, String, Boolean)
- Origine:
- String.Comparison.cs
- Origine:
- String.Comparison.cs
- Origine:
- String.Comparison.cs
Confronta due oggetti String specificati, ignorando o rispettando la distinzione tra maiuscole e minuscole, e restituisce un intero che ne indica la posizione relativa nell'ordinamento.
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
Parametri
- strA
- String
Prima stringa da confrontare.
- strB
- String
Seconda stringa da confrontare.
- ignoreCase
- Boolean
true
per ignorare la distinzione tra maiuscole e minuscole durante il confronto; in caso contrario, false
.
Restituisce
Intero con segno a 32 bit che indica la relazione lessicale tra i due termini di confronto.
Valore | Condizione |
---|---|
Minore di zero | strA precede strB nell'ordinamento.
|
Zero | strA si trova nella stessa posizione di strB nell'ordinamento.
|
Maggiore di zero | strA segue strB nell'ordinamento.
|
Esempio
Nell'esempio seguente viene illustrato che il Compare(String, String, Boolean) metodo è equivalente all'uso ToUpper o ToLower al confronto delle stringhe.
using namespace System;
void main()
{
// 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
// 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
Commenti
Il confronto usa le impostazioni cultura correnti per ottenere informazioni specifiche delle impostazioni cultura, ad esempio le regole di maiuscole e minuscole e l'ordine alfabetico dei singoli caratteri. Ad esempio, le impostazioni cultura potrebbero specificare che determinate combinazioni di caratteri vengano considerate come un singolo carattere o caratteri maiuscoli e minuscoli vengano confrontate in un modo specifico o che l'ordinamento di un carattere dipende dai caratteri che lo precedono o lo seguono.
Il confronto viene eseguito usando le regole di ordinamento delle parole. Per altre informazioni sugli ordinali di parole, stringhe e ordinali, vedere System.Globalization.CompareOptions.
Avviso
Quando si confrontano stringhe, è necessario chiamare il Compare(String, String, StringComparison) metodo , che richiede di specificare in modo esplicito il tipo di confronto tra stringhe utilizzato dal metodo. Per altre informazioni, vedere Best Practices for Using Strings (Procedure consigliate per l'uso di stringhe).
Uno o entrambi i comparand possono essere null
. Per definizione, qualsiasi stringa, inclusa la stringa vuota (""), confronta un riferimento maggiore di un riferimento Null; e due riferimenti Null vengono confrontati tra loro.
Il confronto termina quando viene individuata una disuguaglianza o vengono confrontate entrambe le stringhe. Tuttavia, se le due stringhe confrontano uguale alla fine di una stringa e l'altra contiene caratteri rimanenti, la stringa con i caratteri rimanenti viene considerata maggiore. Il valore restituito è il risultato dell'ultimo confronto eseguito.
I risultati imprevisti possono verificarsi quando i confronti sono interessati da regole di maiuscole e minuscole specifiche delle impostazioni cultura. Ad esempio, in turco, l'esempio seguente restituisce i risultati errati perché il file system in turco non usa regole di maiuscole e minuscole linguistiche per la lettera "i" in "file".
static bool IsFileURI(String^ path)
{
return (String::Compare(path, 0, "file:", 0, 5, true) == 0);
}
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
Confrontare il nome del percorso con "file" usando un confronto ordinale. Il codice corretto per eseguire questa operazione è il seguente:
static bool IsFileURI(String^ path)
{
return (String::Compare(path, 0, "file:", 0, 5, StringComparison::OrdinalIgnoreCase) == 0);
}
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
Note per i chiamanti
I set di caratteri includono caratteri ignorabili. Il Compare(String, String, Boolean) metodo non considera tali caratteri quando esegue un confronto con distinzione tra impostazioni cultura. Ad esempio, se il codice seguente viene eseguito in .NET Framework 4 o versione successiva, un confronto senza distinzione tra le impostazioni cultura e senza distinzione tra maiuscole e minuscole di "animal" con "Ani-mal" (usando un trattino morbido o U+00AD) indica che le due stringhe sono equivalenti.
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
Per riconoscere i caratteri ignorabili in un confronto tra stringhe, chiamare il Compare(String, String, StringComparison) metodo e specificare un valore di Ordinal o OrdinalIgnoreCase per il comparisonType
parametro .
Vedi anche
Si applica a
Compare(String, String)
- Origine:
- String.Comparison.cs
- Origine:
- String.Comparison.cs
- Origine:
- String.Comparison.cs
Confronta due oggetti String specificati e restituisce un intero che ne indica la posizione relativa nell'ordinamento.
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
Parametri
- strA
- String
Prima stringa da confrontare.
- strB
- String
Seconda stringa da confrontare.
Restituisce
Intero con segno a 32 bit che indica la relazione lessicale tra i due termini di confronto.
Valore | Condizione |
---|---|
Minore di zero | strA precede strB nell'ordinamento.
|
Zero | strA si trova nella stessa posizione di strB nell'ordinamento.
|
Maggiore di zero | strA segue strB nell'ordinamento.
|
Esempio
Nell'esempio seguente viene chiamato il Compare(String, String) metodo per confrontare tre set di stringhe.
using namespace System;
void main()
{
// 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
// 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
Nell'esempio seguente la ReverseStringComparer
classe illustra come valutare due stringhe con il Compare metodo .
using namespace System;
using namespace System::Text;
using namespace System::Collections;
ref class ReverseStringComparer: public IComparer
{
public:
virtual int Compare( Object^ x, Object^ y )
{
String^ s1 = dynamic_cast<String^>(x);
String^ s2 = dynamic_cast<String^>(y);
//negate the return value to get the reverse order
return -String::Compare( s1, s2 );
}
};
void PrintValues( String^ title, IEnumerable^ myList )
{
Console::Write( "{0,10}: ", title );
StringBuilder^ sb = gcnew StringBuilder;
{
IEnumerator^ en = myList->GetEnumerator();
String^ s;
while ( en->MoveNext() )
{
s = en->Current->ToString();
sb->AppendFormat( "{0}, ", s );
}
}
sb->Remove( sb->Length - 2, 2 );
Console::WriteLine( sb );
}
void main()
{
// Creates and initializes a new ArrayList.
ArrayList^ myAL = gcnew 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.ToString() );
PrintValues( "Unsorted", myAL );
myAL->Sort();
PrintValues( "Sorted", myAL );
myAL->Sort( gcnew ReverseStringComparer );
PrintValues( "Reverse", myAL );
array<String^>^names = dynamic_cast<array<String^>^>(myAL->ToArray( String::typeid ));
}
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
Commenti
Il confronto usa le impostazioni cultura correnti per ottenere informazioni specifiche delle impostazioni cultura, ad esempio regole di maiuscole e minuscole e ordine alfabetico dei singoli caratteri. Ad esempio, le impostazioni cultura potrebbero specificare che determinate combinazioni di caratteri vengano considerate come un singolo carattere o caratteri maiuscoli e minuscoli vengano confrontate in modo specifico o che l'ordinamento di un carattere dipende dai caratteri che precedono o seguono.
Il confronto viene eseguito usando le regole di ordinamento delle parole. Per altre informazioni su word, string e ordinali, vedere System.Globalization.CompareOptions.
Avviso
Quando si confrontano le stringhe, è necessario chiamare il metodo, che richiede di specificare in modo esplicito il Compare(String, String, StringComparison) tipo di confronto stringa usato dal metodo. Per altre informazioni, vedere Best Practices for Using Strings (Procedure consigliate per l'uso di stringhe).
Uno o entrambi i comparandi possono essere null
. Per definizione, qualsiasi stringa, inclusa la stringa vuota (""), confronta maggiore di un riferimento Null; e due riferimenti Null si confrontano tra loro uguali.
Il confronto termina quando viene rilevata una disuguaglianza o entrambe le stringhe sono state confrontate. Tuttavia, se le due stringhe confrontano uguale alla fine di una stringa e l'altra stringa ha caratteri rimanenti, la stringa con i caratteri rimanenti viene considerata maggiore. Il valore restituito è il risultato dell'ultimo confronto eseguito.
I risultati imprevisti possono verificarsi quando i confronti sono interessati da regole di maiuscole e minuscole specifiche delle impostazioni cultura. Ad esempio, in turco, l'esempio seguente restituisce i risultati sbagliati perché il file system in turco non usa regole di maiuscole e minuscole linguistiche per la lettera "i" in "file".
static bool IsFileURI(String^ path)
{
return (String::Compare(path, 0, "file:", 0, 5, true) == 0);
}
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
Confrontare il nome del percorso con "file" usando un confronto ordinale. Il codice corretto a tale scopo è il seguente:
static bool IsFileURI(String^ path)
{
return (String::Compare(path, 0, "file:", 0, 5, StringComparison::OrdinalIgnoreCase) == 0);
}
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
Note per i chiamanti
I set di caratteri includono caratteri ignorabili. Il Compare(String, String) metodo non considera tali caratteri quando esegue un confronto con distinzione tra impostazioni cultura. Ad esempio, se il codice seguente viene eseguito in .NET Framework 4 o versione successiva, un confronto sensibile alle impostazioni cultura di "animal" con "ani-mal" (usando un trattino morbido o U+00AD) indica che le due stringhe sono equivalenti.
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
Per riconoscere i caratteri ignorabili in un confronto tra stringhe, chiamare il Compare(String, String, StringComparison) metodo e specificare un valore di Ordinal o OrdinalIgnoreCase per il comparisonType
parametro .
Vedi anche
Si applica a
Commenti e suggerimenti
https://aka.ms/ContentUserFeedback.
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedereInvia e visualizza il feedback per