CompareInfo.Compare Método
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Compara dos cadenas.
| Compare(String, String) |
Compara dos cadenas. |
| Compare(ReadOnlySpan<Char>, ReadOnlySpan<Char>, CompareOptions) |
Compara dos intervalos de caracteres de solo lectura. |
| Compare(String, String, CompareOptions) |
Compara dos cadenas utilizando el valor de CompareOptions especificado. |
| Compare(String, Int32, String, Int32) |
Compara la sección final de una cadena con la de otra cadena. |
| Compare(String, Int32, String, Int32, CompareOptions) |
Compara la sección final de una cadena con la de otra utilizando el valor de CompareOptions especificado. |
| Compare(String, Int32, Int32, String, Int32, Int32) |
Compara una sección de una cadena con la de otra cadena. |
| Compare(String, Int32, Int32, String, Int32, Int32, CompareOptions) |
Compara una sección de una cadena con la de otra cadena utilizando el valor de CompareOptions especificado. |
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
Compara dos cadenas.
public:
virtual int Compare(System::String ^ string1, System::String ^ string2);public:
int Compare(System::String ^ string1, System::String ^ string2);public virtual int Compare (string string1, string string2);public int Compare (string? string1, string? string2);public virtual int Compare (string? string1, string? string2);abstract member Compare : string * string -> int
override this.Compare : string * string -> intmember this.Compare : string * string -> intPublic Overridable Function Compare (string1 As String, string2 As String) As IntegerPublic Function Compare (string1 As String, string2 As String) As IntegerParámetros
- string1
- String
Primera cadena que se va a comparar.
- string2
- String
Segunda cadena que se va a comparar.
Devoluciones
Entero de 32 bits con signo que indica la relación léxica que existe entre los dos términos de una comparación.
| Valor | Condición |
|---|---|
| cero | Las dos cadenas son iguales. |
| menor que cero |
string1 es menor que string2.
|
| mayor que cero |
string1 es mayor que string2.
|
Ejemplos
En el ejemplo siguiente se comparan partes de dos cadenas mediante los distintos CompareInfo objetos:
CompareInfo objeto asociado a la referencia cultural española (España) con ordenación internacional
CompareInfo objeto asociado a la referencia cultural española (España) con ordenación tradicional
CompareInfo objeto asociado al objeto InvariantCulture
// The following code example compares two strings using the different CompareInfo instances:
// a CompareInfo instance associated with the S"Spanish - Spain" culture with international sort,
// a CompareInfo instance associated with the S"Spanish - Spain" culture with traditional sort, and
// a CompareInfo instance associated with the InvariantCulture.
using namespace System;
using namespace System::Globalization;
int main()
{
// Defines the strings to compare.
String^ myStr1 = "calle";
String^ myStr2 = "calor";
// Uses GetCompareInfo to create the CompareInfo that
// uses the S"es-ES" culture with international sort.
CompareInfo^ myCompIntl = CompareInfo::GetCompareInfo( "es-ES" );
// Uses GetCompareInfo to create the CompareInfo that
// uses the S"es-ES" culture with traditional sort.
CompareInfo^ myCompTrad = CompareInfo::GetCompareInfo( 0x040A );
// Uses the CompareInfo property of the InvariantCulture.
CompareInfo^ myCompInva = CultureInfo::InvariantCulture->CompareInfo;
// Compares two strings using myCompIntl.
Console::WriteLine( "Comparing \"{0}\" and \"{1}\"", myStr1, myStr2 );
Console::WriteLine( " With myCompIntl::Compare: {0}", myCompIntl->Compare( myStr1, myStr2 ) );
Console::WriteLine( " With myCompTrad::Compare: {0}", myCompTrad->Compare( myStr1, myStr2 ) );
Console::WriteLine( " With myCompInva::Compare: {0}", myCompInva->Compare( myStr1, myStr2 ) );
}
/*
This code produces the following output.
Comparing "calle" and "calor"
With myCompIntl::Compare: -1
With myCompTrad::Compare: 1
With myCompInva::Compare: -1
*/
// The following code example compares two strings using the different CompareInfo instances:
// a CompareInfo instance associated with the "Spanish - Spain" culture with international sort,
// a CompareInfo instance associated with the "Spanish - Spain" culture with traditional sort, and
// a CompareInfo instance associated with the InvariantCulture.
using System;
using System.Globalization;
public class SamplesCompareInfo {
public static void Main() {
// Defines the strings to compare.
String myStr1 = "calle";
String myStr2 = "calor";
// Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with international sort.
CompareInfo myCompIntl = CompareInfo.GetCompareInfo( "es-ES" );
// Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with traditional sort.
CompareInfo myCompTrad = CompareInfo.GetCompareInfo( 0x040A );
// Uses the CompareInfo property of the InvariantCulture.
CompareInfo myCompInva = CultureInfo.InvariantCulture.CompareInfo;
// Compares two strings using myCompIntl.
Console.WriteLine( "Comparing \"{0}\" and \"{1}\"", myStr1, myStr2 );
Console.WriteLine( " With myCompIntl.Compare: {0}", myCompIntl.Compare( myStr1, myStr2 ) );
Console.WriteLine( " With myCompTrad.Compare: {0}", myCompTrad.Compare( myStr1, myStr2 ) );
Console.WriteLine( " With myCompInva.Compare: {0}", myCompInva.Compare( myStr1, myStr2 ) );
}
}
/*
This code produces the following output.
Comparing "calle" and "calor"
With myCompIntl.Compare: -1
With myCompTrad.Compare: 1
With myCompInva.Compare: -1
*/
' The following code example compares two strings using the different CompareInfo instances:
' a CompareInfo instance associated with the "Spanish - Spain" culture with international sort,
' a CompareInfo instance associated with the "Spanish - Spain" culture with traditional sort, and
' a CompareInfo instance associated with the InvariantCulture.
Imports System.Globalization
Public Class SamplesCompareInfo
Public Shared Sub Main()
' Defines the strings to compare.
Dim myStr1 As [String] = "calle"
Dim myStr2 As [String] = "calor"
' Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with international sort.
Dim myCompIntl As CompareInfo = CompareInfo.GetCompareInfo("es-ES")
' Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with traditional sort.
Dim myCompTrad As CompareInfo = CompareInfo.GetCompareInfo(&H40A)
' Uses the CompareInfo property of the InvariantCulture.
Dim myCompInva As CompareInfo = CultureInfo.InvariantCulture.CompareInfo
' Compares two strings using myCompIntl.
Console.WriteLine("Comparing ""{0}"" and ""{1}""", myStr1, myStr2)
Console.WriteLine(" With myCompIntl.Compare: {0}", myCompIntl.Compare(myStr1, myStr2))
Console.WriteLine(" With myCompTrad.Compare: {0}", myCompTrad.Compare(myStr1, myStr2))
Console.WriteLine(" With myCompInva.Compare: {0}", myCompInva.Compare(myStr1, myStr2))
End Sub
End Class
'This code produces the following output.
'
'Comparing "calle" and "calor"
' With myCompIntl.Compare: -1
' With myCompTrad.Compare: 1
' With myCompInva.Compare: -1
En el ejemplo siguiente se muestra la forma de llamar al método Compare.
using namespace System;
using namespace System::Text;
using namespace System::Globalization;
int main()
{
array<String^>^ sign = gcnew array<String^> { "<", "=", ">" };
// The code below demonstrates how strings compare
// differently for different cultures.
String^ s1 = "Coté";
String^ s2 = "coté";
String^ s3 = "côte";
// Set sort order of strings for French in France.
CompareInfo^ ci = (gcnew CultureInfo("fr-FR"))->CompareInfo;
Console::WriteLine(L"The LCID for {0} is {1}.", ci->Name, ci->LCID);
// Display the result using fr-FR Compare of Coté = coté.
Console::WriteLine(L"fr-FR Compare: {0} {2} {1}",
s1, s2, sign[ci->Compare(s1, s2, CompareOptions::IgnoreCase) + 1]);
// Display the result using fr-FR Compare of coté > côte.
Console::WriteLine(L"fr-FR Compare: {0} {2} {1}",
s2, s3, sign[ci->Compare(s2, s3, CompareOptions::None) + 1]);
// Set sort order of strings for Japanese as spoken in Japan.
ci = (gcnew CultureInfo("ja-JP"))->CompareInfo;
Console::WriteLine(L"The LCID for {0} is {1}.", ci->Name, ci->LCID);
// Display the result using ja-JP Compare of coté < côte.
Console::WriteLine("ja-JP Compare: {0} {2} {1}",
s2, s3, sign[ci->Compare(s2, s3) + 1]);
}
// This code produces the following output.
//
// The LCID for fr-FR is 1036.
// fr-FR Compare: Coté = coté
// fr-FR Compare: coté > côte
// The LCID for ja-JP is 1041.
// ja-JP Compare: coté < côte
using System;
using System.Text;
using System.Globalization;
public sealed class App
{
static void Main(string[] args)
{
String[] sign = new String[] { "<", "=", ">" };
// The code below demonstrates how strings compare
// differently for different cultures.
String s1 = "Coté", s2 = "coté", s3 = "côte";
// Set sort order of strings for French in France.
CompareInfo ci = new CultureInfo("fr-FR").CompareInfo;
Console.WriteLine("The LCID for {0} is {1}.", ci.Name, ci.LCID);
// Display the result using fr-FR Compare of Coté = coté.
Console.WriteLine("fr-FR Compare: {0} {2} {1}",
s1, s2, sign[ci.Compare(s1, s2, CompareOptions.IgnoreCase) + 1]);
// Display the result using fr-FR Compare of coté > côte.
Console.WriteLine("fr-FR Compare: {0} {2} {1}",
s2, s3, sign[ci.Compare(s2, s3, CompareOptions.None) + 1]);
// Set sort order of strings for Japanese as spoken in Japan.
ci = new CultureInfo("ja-JP").CompareInfo;
Console.WriteLine("The LCID for {0} is {1}.", ci.Name, ci.LCID);
// Display the result using ja-JP Compare of coté < côte.
Console.WriteLine("ja-JP Compare: {0} {2} {1}",
s2, s3, sign[ci.Compare(s2, s3) + 1]);
}
}
// This code produces the following output.
//
// The LCID for fr-FR is 1036.
// fr-FR Compare: Coté = coté
// fr-FR Compare: coté > côte
// The LCID for ja-JP is 1041.
// ja-JP Compare: coté < côte
Imports System.Text
Imports System.Globalization
NotInheritable Public Class App
Shared Sub Main(ByVal args() As String)
Dim sign() As String = {"<", "=", ">"}
' The code below demonstrates how strings compare
' differently for different cultures.
Dim s1 As String = "Coté"
Dim s2 As String = "coté"
Dim s3 As String = "côte"
' Set sort order of strings for French in France.
Dim ci As CompareInfo = New CultureInfo("fr-FR").CompareInfo
Console.WriteLine("The LCID for {0} is {1}.", ci.Name, ci.LCID)
' Display the result using fr-FR Compare of Coté = coté.
Console.WriteLine("fr-FR Compare: {0} {2} {1}", _
s1, s2, sign((ci.Compare(s1, s2, CompareOptions.IgnoreCase) + 1)))
' Display the result using fr-FR Compare of coté > côte.
Console.WriteLine("fr-FR Compare: {0} {2} {1}", _
s2, s3, sign((ci.Compare(s2, s3, CompareOptions.None) + 1)))
' Set sort order of strings for Japanese as spoken in Japan.
ci = New CultureInfo("ja-JP").CompareInfo
Console.WriteLine("The LCID for {0} is {1}.", ci.Name, ci.LCID)
' Display the result using ja-JP Compare of coté < côte.
Console.WriteLine("ja-JP Compare: {0} {2} {1}", _
s2, s3, sign((ci.Compare(s2, s3) + 1)))
End Sub
End Class
' This code produces the following output.
'
' The LCID for fr-FR is 1036.
' fr-FR Compare: Coté = coté
' fr-FR Compare: coté > côte
' The LCID for ja-JP is 1041.
' ja-JP Compare: coté < côte
Comentarios
De forma predeterminada, la comparación se realiza mediante CompareOptions.None. Si una decisión de seguridad depende de una comparación de cadenas o un cambio de caso, debe usar la InvariantCulture propiedad para asegurarse de que el comportamiento sea coherente independientemente de la configuración de referencia cultural del sistema operativo.
Nota
Cuando sea posible, debe llamar a métodos de comparación de cadenas que tengan un parámetro de tipo CompareOptions para especificar el tipo de comparación esperado. Como regla general, use opciones lingüísticas (mediante la referencia cultural actual) para comparar cadenas mostradas en la interfaz de usuario y especificar Ordinal o OrdinalIgnoreCase para comparaciones de seguridad.
Notas a los autores de las llamadas
Los juegos de caracteres incluyen caracteres que se pueden pasar por alto, que son los caracteres que no se tienen en cuenta al realizar una comparación lingüística o en la que se tiene en cuenta la referencia cultural. El Compare(String, String) método no tiene en cuenta estos caracteres cuando realiza una comparación que distingue la referencia cultural. Por ejemplo, una comparación que distingue la referencia cultural de "animal" con "ani-mal" (mediante un guión suave o U+00AD) indica que las dos cadenas son equivalentes, como se muestra en el ejemplo siguiente.
Imports System.Globalization
Module Example
Public Sub Main()
Dim ci As CompareInfo = CultureInfo.CurrentCulture.CompareInfo
Dim s1 As String = "ani" + ChrW(&h00AD) + "mal"
Dim s2 As String = "animal"
Console.WriteLine("Comparison of '{0}' and '{1}': {2}",
s1, s2, ci.Compare(s1, s2))
End Sub
End Module
' The example displays the following output:
' Comparison of 'ani-mal' and 'animal': 0
Para reconocer caracteres ignorables en una comparación de cadenas, llame al Compare(String, String, CompareOptions) método y proporcione un valor de Ordinal o OrdinalIgnoreCase para el options parámetro .
Se aplica a
.NET 9 y otras versiones
| Producto | Versiones |
|---|---|
| .NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
| .NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
| .NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.6, 2.0, 2.1 |
| UWP | 10.0 |
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
Compara dos intervalos de caracteres de solo lectura.
public int Compare (ReadOnlySpan<char> string1, ReadOnlySpan<char> string2, System.Globalization.CompareOptions options = System.Globalization.CompareOptions.None);member this.Compare : ReadOnlySpan<char> * ReadOnlySpan<char> * System.Globalization.CompareOptions -> intPublic Function Compare (string1 As ReadOnlySpan(Of Char), string2 As ReadOnlySpan(Of Char), Optional options As CompareOptions = System.Globalization.CompareOptions.None) As IntegerParámetros
- string1
- ReadOnlySpan<Char>
Primer intervalo de caracteres de solo lectura que se va a comparar.
- string2
- ReadOnlySpan<Char>
Segundo intervalo de caracteres de solo lectura que se va a comparar.
- options
- CompareOptions
Combinación opcional de los valores de enumeración de CompareOptions que se va a usar durante la comparación. El valor predeterminado es None.
Devoluciones
Cero si string1 y string2 son iguales; un valor negativo si string1 se ordena antes de string2; o bien un valor positivo si string1 se ordena después de string2.
Excepciones
options contiene una combinación no admitida de marcas.
Se aplica a
.NET 9 y otras versiones
| Producto | Versiones |
|---|---|
| .NET | 5, 6, 7, 8, 9 |
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
Compara dos cadenas utilizando el valor de CompareOptions especificado.
public:
virtual int Compare(System::String ^ string1, System::String ^ string2, System::Globalization::CompareOptions options);public:
int Compare(System::String ^ string1, System::String ^ string2, System::Globalization::CompareOptions options);public virtual int Compare (string string1, string string2, System.Globalization.CompareOptions options);public int Compare (string? string1, string? string2, System.Globalization.CompareOptions options);public virtual int Compare (string? string1, string? string2, System.Globalization.CompareOptions options);abstract member Compare : string * string * System.Globalization.CompareOptions -> int
override this.Compare : string * string * System.Globalization.CompareOptions -> intmember this.Compare : string * string * System.Globalization.CompareOptions -> intPublic Overridable Function Compare (string1 As String, string2 As String, options As CompareOptions) As IntegerPublic Function Compare (string1 As String, string2 As String, options As CompareOptions) As IntegerParámetros
- string1
- String
Primera cadena que se va a comparar.
- string2
- String
Segunda cadena que se va a comparar.
- options
- CompareOptions
Valor que define cómo deben compararse los parámetros string1 y string2.
options es el valor de la enumeración Ordinal usado de forma aislada, o una combinación bit a bit de uno o varios de los valores siguientes: IgnoreCase, IgnoreSymbols, IgnoreNonSpace, IgnoreWidth, IgnoreKanaType y StringSort.
Devoluciones
Entero de 32 bits con signo que indica la relación léxica que existe entre los dos términos de una comparación.
| Valor | Condición |
|---|---|
| cero | Las dos cadenas son iguales. |
| menor que cero |
string1 es menor que string2.
|
| mayor que cero |
string1 es mayor que string2.
|
Excepciones
options contiene un valor de CompareOptions no válido.
Ejemplos
En el ejemplo siguiente se comparan dos cadenas con una configuración diferente CompareOptions .
using namespace System;
using namespace System::Globalization;
int main()
{
// Defines the strings to compare.
String^ myStr1 = "My Uncle Bill's clients";
String^ myStr2 = "My uncle bills clients";
// Creates a CompareInfo which uses the InvariantCulture.
CompareInfo^ myComp = CultureInfo::InvariantCulture->CompareInfo;
// Compares two strings using myComp.
Console::WriteLine( "Comparing \"{0}\" and \"{1}\"", myStr1, myStr2 );
Console::WriteLine( " With no CompareOptions : {0}", myComp->Compare( myStr1, myStr2 ) );
Console::WriteLine( " With None : {0}", myComp->Compare( myStr1, myStr2, CompareOptions::None ) );
Console::WriteLine( " With Ordinal : {0}", myComp->Compare( myStr1, myStr2, CompareOptions::Ordinal ) );
Console::WriteLine( " With StringSort : {0}", myComp->Compare( myStr1, myStr2, CompareOptions::StringSort ) );
Console::WriteLine( " With IgnoreCase : {0}", myComp->Compare( myStr1, myStr2, CompareOptions::IgnoreCase ) );
Console::WriteLine( " With IgnoreSymbols : {0}", myComp->Compare( myStr1, myStr2, CompareOptions::IgnoreSymbols ) );
Console::WriteLine( " With IgnoreCase and IgnoreSymbols : {0}", myComp->Compare( myStr1, myStr2, static_cast<CompareOptions>(CompareOptions::IgnoreCase | CompareOptions::IgnoreSymbols) ) );
}
/*
This code produces the following output.
Comparing "My Uncle Bill's clients" and "My uncle bills clients"
With no CompareOptions : 1
With None : 1
With Ordinal : -32
With StringSort : -1
With IgnoreCase : 1
With IgnoreSymbols : 1
With IgnoreCase and IgnoreSymbols : 0
*/
using System;
using System.Globalization;
public class SamplesCompareInfo {
public static void Main() {
// Defines the strings to compare.
String myStr1 = "My Uncle Bill's clients";
String myStr2 = "My uncle bills clients";
// Creates a CompareInfo that uses the InvariantCulture.
CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo;
// Compares two strings using myComp.
Console.WriteLine( "Comparing \"{0}\" and \"{1}\"", myStr1, myStr2 );
Console.WriteLine( " With no CompareOptions : {0}", myComp.Compare( myStr1, myStr2 ) );
Console.WriteLine( " With None : {0}", myComp.Compare( myStr1, myStr2, CompareOptions.None ) );
Console.WriteLine( " With Ordinal : {0}", myComp.Compare( myStr1, myStr2, CompareOptions.Ordinal ) );
Console.WriteLine( " With StringSort : {0}", myComp.Compare( myStr1, myStr2, CompareOptions.StringSort ) );
Console.WriteLine( " With IgnoreCase : {0}", myComp.Compare( myStr1, myStr2, CompareOptions.IgnoreCase ) );
Console.WriteLine( " With IgnoreSymbols : {0}", myComp.Compare( myStr1, myStr2, CompareOptions.IgnoreSymbols ) );
Console.WriteLine( " With IgnoreCase and IgnoreSymbols : {0}", myComp.Compare( myStr1, myStr2, CompareOptions.IgnoreCase | CompareOptions.IgnoreSymbols ) );
}
}
/*
This code produces the following output.
Comparing "My Uncle Bill's clients" and "My uncle bills clients"
With no CompareOptions : 1
With None : 1
With Ordinal : -32
With StringSort : -1
With IgnoreCase : 1
With IgnoreSymbols : 1
With IgnoreCase and IgnoreSymbols : 0
*/
Imports System.Globalization
Public Class SamplesCompareInfo
Public Shared Sub Main()
' Defines the strings to compare.
Dim myStr1 As [String] = "My Uncle Bill's clients"
Dim myStr2 As [String] = "My uncle bills clients"
' Creates a CompareInfo that uses the InvariantCulture.
Dim myComp As CompareInfo = CultureInfo.InvariantCulture.CompareInfo
' Compares two strings using myComp.
Console.WriteLine("Comparing ""{0}"" and ""{1}""", myStr1, myStr2)
Console.WriteLine(" With no CompareOptions : {0}", myComp.Compare(myStr1, myStr2))
Console.WriteLine(" With None : {0}", myComp.Compare(myStr1, myStr2, CompareOptions.None))
Console.WriteLine(" With Ordinal : {0}", myComp.Compare(myStr1, myStr2, CompareOptions.Ordinal))
Console.WriteLine(" With StringSort : {0}", myComp.Compare(myStr1, myStr2, CompareOptions.StringSort))
Console.WriteLine(" With IgnoreCase : {0}", myComp.Compare(myStr1, myStr2, CompareOptions.IgnoreCase))
Console.WriteLine(" With IgnoreSymbols : {0}", myComp.Compare(myStr1, myStr2, CompareOptions.IgnoreSymbols))
Console.WriteLine(" With IgnoreCase and IgnoreSymbols : {0}", myComp.Compare(myStr1, myStr2, CompareOptions.IgnoreCase Or CompareOptions.IgnoreSymbols))
End Sub
End Class
'This code produces the following output.
'
'Comparing "My Uncle Bill's clients" and "My uncle bills clients"
' With no CompareOptions : 1
' With None : 1
' With Ordinal : -32
' With StringSort : -1
' With IgnoreCase : 1
' With IgnoreSymbols : 1
' With IgnoreCase and IgnoreSymbols : 0
En el ejemplo siguiente se muestra la forma de llamar al método Compare.
using namespace System;
using namespace System::Text;
using namespace System::Globalization;
int main()
{
array<String^>^ sign = gcnew array<String^> { "<", "=", ">" };
// The code below demonstrates how strings compare
// differently for different cultures.
String^ s1 = "Coté";
String^ s2 = "coté";
String^ s3 = "côte";
// Set sort order of strings for French in France.
CompareInfo^ ci = (gcnew CultureInfo("fr-FR"))->CompareInfo;
Console::WriteLine(L"The LCID for {0} is {1}.", ci->Name, ci->LCID);
// Display the result using fr-FR Compare of Coté = coté.
Console::WriteLine(L"fr-FR Compare: {0} {2} {1}",
s1, s2, sign[ci->Compare(s1, s2, CompareOptions::IgnoreCase) + 1]);
// Display the result using fr-FR Compare of coté > côte.
Console::WriteLine(L"fr-FR Compare: {0} {2} {1}",
s2, s3, sign[ci->Compare(s2, s3, CompareOptions::None) + 1]);
// Set sort order of strings for Japanese as spoken in Japan.
ci = (gcnew CultureInfo("ja-JP"))->CompareInfo;
Console::WriteLine(L"The LCID for {0} is {1}.", ci->Name, ci->LCID);
// Display the result using ja-JP Compare of coté < côte.
Console::WriteLine("ja-JP Compare: {0} {2} {1}",
s2, s3, sign[ci->Compare(s2, s3) + 1]);
}
// This code produces the following output.
//
// The LCID for fr-FR is 1036.
// fr-FR Compare: Coté = coté
// fr-FR Compare: coté > côte
// The LCID for ja-JP is 1041.
// ja-JP Compare: coté < côte
using System;
using System.Text;
using System.Globalization;
public sealed class App
{
static void Main(string[] args)
{
String[] sign = new String[] { "<", "=", ">" };
// The code below demonstrates how strings compare
// differently for different cultures.
String s1 = "Coté", s2 = "coté", s3 = "côte";
// Set sort order of strings for French in France.
CompareInfo ci = new CultureInfo("fr-FR").CompareInfo;
Console.WriteLine("The LCID for {0} is {1}.", ci.Name, ci.LCID);
// Display the result using fr-FR Compare of Coté = coté.
Console.WriteLine("fr-FR Compare: {0} {2} {1}",
s1, s2, sign[ci.Compare(s1, s2, CompareOptions.IgnoreCase) + 1]);
// Display the result using fr-FR Compare of coté > côte.
Console.WriteLine("fr-FR Compare: {0} {2} {1}",
s2, s3, sign[ci.Compare(s2, s3, CompareOptions.None) + 1]);
// Set sort order of strings for Japanese as spoken in Japan.
ci = new CultureInfo("ja-JP").CompareInfo;
Console.WriteLine("The LCID for {0} is {1}.", ci.Name, ci.LCID);
// Display the result using ja-JP Compare of coté < côte.
Console.WriteLine("ja-JP Compare: {0} {2} {1}",
s2, s3, sign[ci.Compare(s2, s3) + 1]);
}
}
// This code produces the following output.
//
// The LCID for fr-FR is 1036.
// fr-FR Compare: Coté = coté
// fr-FR Compare: coté > côte
// The LCID for ja-JP is 1041.
// ja-JP Compare: coté < côte
Imports System.Text
Imports System.Globalization
NotInheritable Public Class App
Shared Sub Main(ByVal args() As String)
Dim sign() As String = {"<", "=", ">"}
' The code below demonstrates how strings compare
' differently for different cultures.
Dim s1 As String = "Coté"
Dim s2 As String = "coté"
Dim s3 As String = "côte"
' Set sort order of strings for French in France.
Dim ci As CompareInfo = New CultureInfo("fr-FR").CompareInfo
Console.WriteLine("The LCID for {0} is {1}.", ci.Name, ci.LCID)
' Display the result using fr-FR Compare of Coté = coté.
Console.WriteLine("fr-FR Compare: {0} {2} {1}", _
s1, s2, sign((ci.Compare(s1, s2, CompareOptions.IgnoreCase) + 1)))
' Display the result using fr-FR Compare of coté > côte.
Console.WriteLine("fr-FR Compare: {0} {2} {1}", _
s2, s3, sign((ci.Compare(s2, s3, CompareOptions.None) + 1)))
' Set sort order of strings for Japanese as spoken in Japan.
ci = New CultureInfo("ja-JP").CompareInfo
Console.WriteLine("The LCID for {0} is {1}.", ci.Name, ci.LCID)
' Display the result using ja-JP Compare of coté < côte.
Console.WriteLine("ja-JP Compare: {0} {2} {1}", _
s2, s3, sign((ci.Compare(s2, s3) + 1)))
End Sub
End Class
' This code produces the following output.
'
' The LCID for fr-FR is 1036.
' fr-FR Compare: Coté = coté
' fr-FR Compare: coté > côte
' The LCID for ja-JP is 1041.
' ja-JP Compare: coté < côte
Comentarios
Si una decisión de seguridad depende de una comparación de cadenas o un cambio de caso, debe usar la InvariantCulture propiedad para asegurarse de que el comportamiento sea coherente independientemente de la configuración de referencia cultural del sistema operativo.
Nota
Cuando sea posible, debe llamar a métodos de comparación de cadenas que tengan un parámetro de tipo CompareOptions para especificar el tipo de comparación esperado. Como regla general, use opciones lingüísticas (mediante la referencia cultural actual) para comparar cadenas mostradas en la interfaz de usuario y especificar Ordinal o OrdinalIgnoreCase para comparaciones de seguridad.
Notas a los autores de las llamadas
Los juegos de caracteres incluyen caracteres que se pueden pasar por alto, que son los caracteres que no se tienen en cuenta al realizar una comparación lingüística o en la que se tiene en cuenta la referencia cultural. El Compare(String, String, CompareOptions) método no tiene en cuenta estos caracteres cuando realiza una comparación que distingue la referencia cultural. Para reconocer caracteres ignorables en la comparación, proporcione un valor de Ordinal o OrdinalIgnoreCase para el options parámetro .
Consulte también
Se aplica a
.NET 9 y otras versiones
| Producto | Versiones |
|---|---|
| .NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
| .NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
| .NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.6, 2.0, 2.1 |
| UWP | 10.0 |
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
Compara la sección final de una cadena con la de otra cadena.
public:
virtual int Compare(System::String ^ string1, int offset1, System::String ^ string2, int offset2);public:
int Compare(System::String ^ string1, int offset1, System::String ^ string2, int offset2);public virtual int Compare (string string1, int offset1, string string2, int offset2);public int Compare (string? string1, int offset1, string? string2, int offset2);public virtual int Compare (string? string1, int offset1, string? string2, int offset2);abstract member Compare : string * int * string * int -> int
override this.Compare : string * int * string * int -> intmember this.Compare : string * int * string * int -> intPublic Overridable Function Compare (string1 As String, offset1 As Integer, string2 As String, offset2 As Integer) As IntegerPublic Function Compare (string1 As String, offset1 As Integer, string2 As String, offset2 As Integer) As IntegerParámetros
- string1
- String
Primera cadena que se va a comparar.
- offset1
- Int32
Índice de base cero del carácter de string1 donde se va a iniciar la comparación.
- string2
- String
Segunda cadena que se va a comparar.
- offset2
- Int32
Índice de base cero del carácter de string2 donde se va a iniciar la comparación.
Devoluciones
Entero de 32 bits con signo que indica la relación léxica que existe entre los dos términos de una comparación.
| Valor | Condición |
|---|---|
| cero | Las dos cadenas son iguales. |
| menor que cero | La sección especificada de string1 es menor que la sección especificada de string2.
|
| mayor que cero | La sección especificada de string1 es mayor que la sección especificada de string2.
|
Excepciones
offset1 o offset2 es menor que cero.
O bien
offset1 es igual o mayor que el número de caracteres de string1.
O bien
offset2 es igual o mayor que el número de caracteres de string2.
Ejemplos
En el ejemplo siguiente se comparan partes de dos cadenas mediante los distintos CompareInfo objetos:
CompareInfo objeto asociado a la referencia cultural española (España) con ordenación internacional
CompareInfo objeto asociado a la referencia cultural española (España) con ordenación tradicional
CompareInfo objeto asociado al objeto InvariantCulture
using namespace System;
using namespace System::Globalization;
int main()
{
// Defines the strings to compare.
String^ myStr1 = "calle";
String^ myStr2 = "calor";
// Uses GetCompareInfo to create the CompareInfo that
// uses the S"es-ES" culture with international sort.
CompareInfo^ myCompIntl = CompareInfo::GetCompareInfo( "es-ES" );
// Uses GetCompareInfo to create the CompareInfo that
// uses the S"es-ES" culture with traditional sort.
CompareInfo^ myCompTrad = CompareInfo::GetCompareInfo( 0x040A );
// Uses the CompareInfo property of the InvariantCulture.
CompareInfo^ myCompInva = CultureInfo::InvariantCulture->CompareInfo;
// Compares two strings using myCompIntl.
Console::WriteLine( "Comparing \"{0}\" and \"{1}\"", myStr1->Substring( 2 ), myStr2->Substring( 2 ) );
Console::WriteLine( " With myCompIntl::Compare: {0}", myCompIntl->Compare( myStr1, 2, myStr2, 2 ) );
Console::WriteLine( " With myCompTrad::Compare: {0}", myCompTrad->Compare( myStr1, 2, myStr2, 2 ) );
Console::WriteLine( " With myCompInva::Compare: {0}", myCompInva->Compare( myStr1, 2, myStr2, 2 ) );
}
/*
This code produces the following output.
Comparing "lle" and "lor"
With myCompIntl::Compare: -1
With myCompTrad::Compare: 1
With myCompInva::Compare: -1
*/
using System;
using System.Globalization;
public class SamplesCompareInfo {
public static void Main() {
// Defines the strings to compare.
String myStr1 = "calle";
String myStr2 = "calor";
// Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with international sort.
CompareInfo myCompIntl = CompareInfo.GetCompareInfo( "es-ES" );
// Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with traditional sort.
CompareInfo myCompTrad = CompareInfo.GetCompareInfo( 0x040A );
// Uses the CompareInfo property of the InvariantCulture.
CompareInfo myCompInva = CultureInfo.InvariantCulture.CompareInfo;
// Compares two strings using myCompIntl.
Console.WriteLine( "Comparing \"{0}\" and \"{1}\"", myStr1.Substring( 2 ), myStr2.Substring( 2 ) );
Console.WriteLine( " With myCompIntl.Compare: {0}", myCompIntl.Compare( myStr1, 2, myStr2, 2 ) );
Console.WriteLine( " With myCompTrad.Compare: {0}", myCompTrad.Compare( myStr1, 2, myStr2, 2 ) );
Console.WriteLine( " With myCompInva.Compare: {0}", myCompInva.Compare( myStr1, 2, myStr2, 2 ) );
}
}
/*
This code produces the following output.
Comparing "lle" and "lor"
With myCompIntl.Compare: -1
With myCompTrad.Compare: 1
With myCompInva.Compare: -1
*/
Imports System.Globalization
Public Class SamplesCompareInfo
Public Shared Sub Main()
' Defines the strings to compare.
Dim myStr1 As [String] = "calle"
Dim myStr2 As [String] = "calor"
' Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with international sort.
Dim myCompIntl As CompareInfo = CompareInfo.GetCompareInfo("es-ES")
' Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with traditional sort.
Dim myCompTrad As CompareInfo = CompareInfo.GetCompareInfo(&H40A)
' Uses the CompareInfo property of the InvariantCulture.
Dim myCompInva As CompareInfo = CultureInfo.InvariantCulture.CompareInfo
' Compares two strings using myCompIntl.
Console.WriteLine("Comparing ""{0}"" and ""{1}""", myStr1.Substring(2), myStr2.Substring(2))
Console.WriteLine(" With myCompIntl.Compare: {0}", myCompIntl.Compare(myStr1, 2, myStr2, 2))
Console.WriteLine(" With myCompTrad.Compare: {0}", myCompTrad.Compare(myStr1, 2, myStr2, 2))
Console.WriteLine(" With myCompInva.Compare: {0}", myCompInva.Compare(myStr1, 2, myStr2, 2))
End Sub
End Class
'This code produces the following output.
'
'Comparing "lle" and "lor"
' With myCompIntl.Compare: -1
' With myCompTrad.Compare: 1
' With myCompInva.Compare: -1
Comentarios
Si una decisión de seguridad depende de una comparación de cadenas o un cambio de caso, debe usar la InvariantCulture propiedad para asegurarse de que el comportamiento sea coherente independientemente de la configuración de referencia cultural del sistema operativo.
Nota
Cuando sea posible, debe llamar a métodos de comparación de cadenas que tengan un parámetro de tipo CompareOptions para especificar el tipo de comparación esperado. Como regla general, use opciones lingüísticas (mediante la referencia cultural actual) para comparar cadenas mostradas en la interfaz de usuario y especificar Ordinal o OrdinalIgnoreCase para comparaciones de seguridad.
Notas a los autores de las llamadas
Los juegos de caracteres incluyen caracteres que se pueden pasar por alto. El Compare(String, Int32, String, Int32) método no tiene en cuenta estos caracteres cuando realiza una comparación lingüística o sensible a la referencia cultural. Para reconocer caracteres ignorables en la comparación, llame al Compare(String, Int32, String, Int32, CompareOptions) método y proporcione un valor de Ordinal o OrdinalIgnoreCase para el options parámetro .
Se aplica a
.NET 9 y otras versiones
| Producto | Versiones |
|---|---|
| .NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
| .NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
| .NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.6, 2.0, 2.1 |
| UWP | 10.0 |
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
Compara la sección final de una cadena con la de otra utilizando el valor de CompareOptions especificado.
public:
virtual int Compare(System::String ^ string1, int offset1, System::String ^ string2, int offset2, System::Globalization::CompareOptions options);public:
int Compare(System::String ^ string1, int offset1, System::String ^ string2, int offset2, System::Globalization::CompareOptions options);public virtual int Compare (string string1, int offset1, string string2, int offset2, System.Globalization.CompareOptions options);public int Compare (string? string1, int offset1, string? string2, int offset2, System.Globalization.CompareOptions options);public virtual int Compare (string? string1, int offset1, string? string2, int offset2, System.Globalization.CompareOptions options);abstract member Compare : string * int * string * int * System.Globalization.CompareOptions -> int
override this.Compare : string * int * string * int * System.Globalization.CompareOptions -> intmember this.Compare : string * int * string * int * System.Globalization.CompareOptions -> intPublic Overridable Function Compare (string1 As String, offset1 As Integer, string2 As String, offset2 As Integer, options As CompareOptions) As IntegerPublic Function Compare (string1 As String, offset1 As Integer, string2 As String, offset2 As Integer, options As CompareOptions) As IntegerParámetros
- string1
- String
Primera cadena que se va a comparar.
- offset1
- Int32
Índice de base cero del carácter de string1 donde se va a iniciar la comparación.
- string2
- String
Segunda cadena que se va a comparar.
- offset2
- Int32
Índice de base cero del carácter de string2 donde se va a iniciar la comparación.
- options
- CompareOptions
Valor que define cómo deben compararse los parámetros string1 y string2.
options es el valor de la enumeración Ordinal usado de forma aislada, o una combinación bit a bit de uno o varios de los valores siguientes: IgnoreCase, IgnoreSymbols, IgnoreNonSpace, IgnoreWidth, IgnoreKanaType y StringSort.
Devoluciones
Entero de 32 bits con signo que indica la relación léxica que existe entre los dos términos de una comparación.
| Valor | Condición |
|---|---|
| cero | Las dos cadenas son iguales. |
| menor que cero | La sección especificada de string1 es menor que la sección especificada de string2.
|
| mayor que cero | La sección especificada de string1 es mayor que la sección especificada de string2.
|
Excepciones
offset1 o offset2 es menor que cero.
O bien
offset1 es igual o mayor que el número de caracteres de string1.
O bien
offset2 es igual o mayor que el número de caracteres de string2.
options contiene un valor de CompareOptions no válido.
Ejemplos
En el ejemplo siguiente se comparan partes de dos cadenas con una configuración diferente CompareOptions .
using namespace System;
using namespace System::Globalization;
int main()
{
// Defines the strings to compare.
String^ myStr1 = "My Uncle Bill's clients";
String^ myStr2 = "My uncle bills clients";
// Creates a CompareInfo that uses the InvariantCulture.
CompareInfo^ myComp = CultureInfo::InvariantCulture->CompareInfo;
// Compares two strings using myComp.
Console::WriteLine( "Comparing \"{0}\" and \"{1}\"", myStr1->Substring( 10 ), myStr2->Substring( 10 ) );
Console::WriteLine( " With no CompareOptions : {0}", myComp->Compare( myStr1, 10, myStr2, 10 ) );
Console::WriteLine( " With None : {0}", myComp->Compare( myStr1, 10, myStr2, 10, CompareOptions::None ) );
Console::WriteLine( " With Ordinal : {0}", myComp->Compare( myStr1, 10, myStr2, 10, CompareOptions::Ordinal ) );
Console::WriteLine( " With StringSort : {0}", myComp->Compare( myStr1, 10, myStr2, 10, CompareOptions::StringSort ) );
Console::WriteLine( " With IgnoreCase : {0}", myComp->Compare( myStr1, 10, myStr2, 10, CompareOptions::IgnoreCase ) );
Console::WriteLine( " With IgnoreSymbols : {0}", myComp->Compare( myStr1, 10, myStr2, 10, CompareOptions::IgnoreSymbols ) );
Console::WriteLine( " With IgnoreCase and IgnoreSymbols : {0}", myComp->Compare( myStr1, 10, myStr2, 10, static_cast<CompareOptions>(CompareOptions::IgnoreCase | CompareOptions::IgnoreSymbols) ) );
}
/*
This code produces the following output.
Comparing "ill's clients" and "ills clients"
With no CompareOptions : 1
With None : 1
With Ordinal : -76
With StringSort : -1
With IgnoreCase : 1
With IgnoreSymbols : 0
With IgnoreCase and IgnoreSymbols : 0
*/
using System;
using System.Globalization;
public class SamplesCompareInfo {
public static void Main() {
// Defines the strings to compare.
String myStr1 = "My Uncle Bill's clients";
String myStr2 = "My uncle bills clients";
// Creates a CompareInfo that uses the InvariantCulture.
CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo;
// Compares two strings using myComp.
Console.WriteLine( "Comparing \"{0}\" and \"{1}\"", myStr1.Substring( 10 ), myStr2.Substring( 10 ) );
Console.WriteLine( " With no CompareOptions : {0}", myComp.Compare( myStr1, 10, myStr2, 10 ) );
Console.WriteLine( " With None : {0}", myComp.Compare( myStr1, 10, myStr2, 10, CompareOptions.None ) );
Console.WriteLine( " With Ordinal : {0}", myComp.Compare( myStr1, 10, myStr2, 10, CompareOptions.Ordinal ) );
Console.WriteLine( " With StringSort : {0}", myComp.Compare( myStr1, 10, myStr2, 10, CompareOptions.StringSort ) );
Console.WriteLine( " With IgnoreCase : {0}", myComp.Compare( myStr1, 10, myStr2, 10, CompareOptions.IgnoreCase ) );
Console.WriteLine( " With IgnoreSymbols : {0}", myComp.Compare( myStr1, 10, myStr2, 10, CompareOptions.IgnoreSymbols ) );
Console.WriteLine( " With IgnoreCase and IgnoreSymbols : {0}", myComp.Compare( myStr1, 10, myStr2, 10, CompareOptions.IgnoreCase | CompareOptions.IgnoreSymbols ) );
}
}
/*
This code produces the following output.
Comparing "ill's clients" and "ills clients"
With no CompareOptions : 1
With None : 1
With Ordinal : -76
With StringSort : -1
With IgnoreCase : 1
With IgnoreSymbols : 0
With IgnoreCase and IgnoreSymbols : 0
*/
Imports System.Globalization
Public Class SamplesCompareInfo
Public Shared Sub Main()
' Defines the strings to compare.
Dim myStr1 As [String] = "My Uncle Bill's clients"
Dim myStr2 As [String] = "My uncle bills clients"
' Creates a CompareInfo that uses the InvariantCulture.
Dim myComp As CompareInfo = CultureInfo.InvariantCulture.CompareInfo
' Compares two strings using myComp.
Console.WriteLine("Comparing ""{0}"" and ""{1}""", myStr1.Substring(10), myStr2.Substring(10))
Console.WriteLine(" With no CompareOptions : {0}", myComp.Compare(myStr1, 10, myStr2, 10))
Console.WriteLine(" With None : {0}", myComp.Compare(myStr1, 10, myStr2, 10, CompareOptions.None))
Console.WriteLine(" With Ordinal : {0}", myComp.Compare(myStr1, 10, myStr2, 10, CompareOptions.Ordinal))
Console.WriteLine(" With StringSort : {0}", myComp.Compare(myStr1, 10, myStr2, 10, CompareOptions.StringSort))
Console.WriteLine(" With IgnoreCase : {0}", myComp.Compare(myStr1, 10, myStr2, 10, CompareOptions.IgnoreCase))
Console.WriteLine(" With IgnoreSymbols : {0}", myComp.Compare(myStr1, 10, myStr2, 10, CompareOptions.IgnoreSymbols))
Console.WriteLine(" With IgnoreCase and IgnoreSymbols : {0}", myComp.Compare(myStr1, 10, myStr2, 10, CompareOptions.IgnoreCase Or CompareOptions.IgnoreSymbols))
End Sub
End Class
'This code produces the following output.
'
'Comparing "ill's clients" and "ills clients"
' With no CompareOptions : 1
' With None : 1
' With Ordinal : -76
' With StringSort : -1
' With IgnoreCase : 1
' With IgnoreSymbols : 0
' With IgnoreCase and IgnoreSymbols : 0
Comentarios
Si una decisión de seguridad depende de una comparación de cadenas o un cambio de caso, debe usar la InvariantCulture propiedad para asegurarse de que el comportamiento sea coherente independientemente de la configuración de referencia cultural del sistema operativo.
Nota
Cuando sea posible, debe llamar a métodos de comparación de cadenas que tengan un parámetro de tipo CompareOptions para especificar el tipo de comparación esperado. Como regla general, use opciones lingüísticas (mediante la referencia cultural actual) para comparar cadenas mostradas en la interfaz de usuario y especificar Ordinal o OrdinalIgnoreCase para comparaciones de seguridad.
Notas a los autores de las llamadas
Los juegos de caracteres incluyen caracteres que se pueden pasar por alto, que son los caracteres que no se tienen en cuenta al realizar una comparación lingüística o en la que se tiene en cuenta la referencia cultural. El Compare(String, Int32, String, Int32, CompareOptions) método no tiene en cuenta estos caracteres al realizar una comparación que distingue la referencia cultural. Para reconocer caracteres ignorables en la comparación, proporcione un valor de Ordinal o OrdinalIgnoreCase para el options parámetro .
Consulte también
Se aplica a
.NET 9 y otras versiones
| Producto | Versiones |
|---|---|
| .NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
| .NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
| .NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.6, 2.0, 2.1 |
| UWP | 10.0 |
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
Compara una sección de una cadena con la de otra cadena.
public:
virtual int Compare(System::String ^ string1, int offset1, int length1, System::String ^ string2, int offset2, int length2);public:
int Compare(System::String ^ string1, int offset1, int length1, System::String ^ string2, int offset2, int length2);public virtual int Compare (string string1, int offset1, int length1, string string2, int offset2, int length2);public int Compare (string? string1, int offset1, int length1, string? string2, int offset2, int length2);public virtual int Compare (string? string1, int offset1, int length1, string? string2, int offset2, int length2);abstract member Compare : string * int * int * string * int * int -> int
override this.Compare : string * int * int * string * int * int -> intmember this.Compare : string * int * int * string * int * int -> intPublic Overridable Function Compare (string1 As String, offset1 As Integer, length1 As Integer, string2 As String, offset2 As Integer, length2 As Integer) As IntegerPublic Function Compare (string1 As String, offset1 As Integer, length1 As Integer, string2 As String, offset2 As Integer, length2 As Integer) As IntegerParámetros
- string1
- String
Primera cadena que se va a comparar.
- offset1
- Int32
Índice de base cero del carácter de string1 donde se va a iniciar la comparación.
- length1
- Int32
Número de caracteres consecutivos de string1 que se van a comparar.
- string2
- String
Segunda cadena que se va a comparar.
- offset2
- Int32
Índice de base cero del carácter de string2 donde se va a iniciar la comparación.
- length2
- Int32
Número de caracteres consecutivos de string2 que se van a comparar.
Devoluciones
Entero de 32 bits con signo que indica la relación léxica que existe entre los dos términos de una comparación.
| Valor | Condición |
|---|---|
| cero | Las dos cadenas son iguales. |
| menor que cero | La sección especificada de string1 es menor que la sección especificada de string2.
|
| mayor que cero | La sección especificada de string1 es mayor que la sección especificada de string2.
|
Excepciones
offset1 o length1 u offset2 o length2 es menor que cero.
O bien
offset1 es igual o mayor que el número de caracteres de string1.
O bien
offset2 es igual o mayor que el número de caracteres de string2.
O bien
length1 es mayor que el número de caracteres desde offset1 hasta el final de string1.
O bien
length2 es mayor que el número de caracteres desde offset2 hasta el final de string2.
Ejemplos
En el ejemplo siguiente se comparan partes de dos cadenas mediante los distintos CompareInfo objetos:
CompareInfo objeto asociado a la referencia cultural española (España) con ordenación internacional
CompareInfo objeto asociado a la referencia cultural española (España) con ordenación tradicional
CompareInfo objeto asociado al objeto InvariantCulture
using namespace System;
using namespace System::Globalization;
int main()
{
// Defines the strings to compare.
String^ myStr1 = "calle";
String^ myStr2 = "calor";
// Uses GetCompareInfo to create the CompareInfo that uses the S"es-ES" culture with international sort.
CompareInfo^ myCompIntl = CompareInfo::GetCompareInfo( "es-ES" );
// Uses GetCompareInfo to create the CompareInfo that uses the S"es-ES" culture with traditional sort.
CompareInfo^ myCompTrad = CompareInfo::GetCompareInfo( 0x040A );
// Uses the CompareInfo property of the InvariantCulture.
CompareInfo^ myCompInva = CultureInfo::InvariantCulture->CompareInfo;
// Compares two strings using myCompIntl.
Console::WriteLine( "Comparing \" {0}\" and \" {1}\"", myStr1->Substring( 2, 2 ), myStr2->Substring( 2, 2 ) );
Console::WriteLine( " With myCompIntl->Compare: {0}", myCompIntl->Compare( myStr1, 2, 2, myStr2, 2, 2 ) );
Console::WriteLine( " With myCompTrad->Compare: {0}", myCompTrad->Compare( myStr1, 2, 2, myStr2, 2, 2 ) );
Console::WriteLine( " With myCompInva->Compare: {0}", myCompInva->Compare( myStr1, 2, 2, myStr2, 2, 2 ) );
}
/*
This code produces the following output.
Comparing S"ll" and S"lo"
With myCompIntl.Compare: -1
With myCompTrad.Compare: 1
With myCompInva.Compare: -1
*/
using System;
using System.Globalization;
public class SamplesCompareInfo {
public static void Main() {
// Defines the strings to compare.
String myStr1 = "calle";
String myStr2 = "calor";
// Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with international sort.
CompareInfo myCompIntl = CompareInfo.GetCompareInfo( "es-ES" );
// Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with traditional sort.
CompareInfo myCompTrad = CompareInfo.GetCompareInfo( 0x040A );
// Uses the CompareInfo property of the InvariantCulture.
CompareInfo myCompInva = CultureInfo.InvariantCulture.CompareInfo;
// Compares two strings using myCompIntl.
Console.WriteLine( "Comparing \"{0}\" and \"{1}\"", myStr1.Substring( 2, 2 ), myStr2.Substring( 2, 2 ) );
Console.WriteLine( " With myCompIntl.Compare: {0}", myCompIntl.Compare( myStr1, 2, 2, myStr2, 2, 2 ) );
Console.WriteLine( " With myCompTrad.Compare: {0}", myCompTrad.Compare( myStr1, 2, 2, myStr2, 2, 2 ) );
Console.WriteLine( " With myCompInva.Compare: {0}", myCompInva.Compare( myStr1, 2, 2, myStr2, 2, 2 ) );
}
}
/*
This code produces the following output.
Comparing "ll" and "lo"
With myCompIntl.Compare: -1
With myCompTrad.Compare: 1
With myCompInva.Compare: -1
*/
Imports System.Globalization
Public Class SamplesCompareInfo
Public Shared Sub Main()
' Defines the strings to compare.
Dim myStr1 As [String] = "calle"
Dim myStr2 As [String] = "calor"
' Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with international sort.
Dim myCompIntl As CompareInfo = CompareInfo.GetCompareInfo("es-ES")
' Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with traditional sort.
Dim myCompTrad As CompareInfo = CompareInfo.GetCompareInfo(&H40A)
' Uses the CompareInfo property of the InvariantCulture.
Dim myCompInva As CompareInfo = CultureInfo.InvariantCulture.CompareInfo
' Compares two strings using myCompIntl.
Console.WriteLine("Comparing ""{0}"" and ""{1}""", myStr1.Substring(2, 2), myStr2.Substring(2, 2))
Console.WriteLine(" With myCompIntl.Compare: {0}", myCompIntl.Compare(myStr1, 2, 2, myStr2, 2, 2))
Console.WriteLine(" With myCompTrad.Compare: {0}", myCompTrad.Compare(myStr1, 2, 2, myStr2, 2, 2))
Console.WriteLine(" With myCompInva.Compare: {0}", myCompInva.Compare(myStr1, 2, 2, myStr2, 2, 2))
End Sub
End Class
'This code produces the following output.
'
'Comparing "ll" and "lo"
' With myCompIntl.Compare: -1
' With myCompTrad.Compare: 1
' With myCompInva.Compare: -1
Comentarios
Si una decisión de seguridad depende de una comparación de cadenas o un cambio de caso, debe usar la InvariantCulture propiedad para asegurarse de que el comportamiento sea coherente independientemente de la configuración de referencia cultural del sistema operativo.
Nota
Cuando sea posible, debe usar métodos de comparación de cadenas que tengan un parámetro de tipo CompareOptions para especificar el tipo de comparación esperado. Como regla general, use opciones lingüísticas (mediante la referencia cultural actual) para comparar cadenas mostradas en la interfaz de usuario y especificar Ordinal o OrdinalIgnoreCase para comparaciones de seguridad.
Notas a los autores de las llamadas
Los juegos de caracteres incluyen caracteres que se pueden pasar por alto. El Compare(String, Int32, Int32, String, Int32, Int32) método no tiene en cuenta estos caracteres cuando realiza una comparación lingüística o sensible a la referencia cultural. Para reconocer caracteres ignorables en la comparación, llame al Compare(String, Int32, Int32, String, Int32, Int32, CompareOptions) método y proporcione un valor de Ordinal o OrdinalIgnoreCase para el options parámetro .
Se aplica a
.NET 9 y otras versiones
| Producto | Versiones |
|---|---|
| .NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
| .NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
| .NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.6, 2.0, 2.1 |
| UWP | 10.0 |
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
- Source:
- CompareInfo.cs
Compara una sección de una cadena con la de otra cadena utilizando el valor de CompareOptions especificado.
public:
virtual int Compare(System::String ^ string1, int offset1, int length1, System::String ^ string2, int offset2, int length2, System::Globalization::CompareOptions options);public:
int Compare(System::String ^ string1, int offset1, int length1, System::String ^ string2, int offset2, int length2, System::Globalization::CompareOptions options);public virtual int Compare (string string1, int offset1, int length1, string string2, int offset2, int length2, System.Globalization.CompareOptions options);public int Compare (string? string1, int offset1, int length1, string? string2, int offset2, int length2, System.Globalization.CompareOptions options);public virtual int Compare (string? string1, int offset1, int length1, string? string2, int offset2, int length2, System.Globalization.CompareOptions options);abstract member Compare : string * int * int * string * int * int * System.Globalization.CompareOptions -> int
override this.Compare : string * int * int * string * int * int * System.Globalization.CompareOptions -> intmember this.Compare : string * int * int * string * int * int * System.Globalization.CompareOptions -> intPublic Overridable Function Compare (string1 As String, offset1 As Integer, length1 As Integer, string2 As String, offset2 As Integer, length2 As Integer, options As CompareOptions) As IntegerPublic Function Compare (string1 As String, offset1 As Integer, length1 As Integer, string2 As String, offset2 As Integer, length2 As Integer, options As CompareOptions) As IntegerParámetros
- string1
- String
Primera cadena que se va a comparar.
- offset1
- Int32
Índice de base cero del carácter de string1 donde se va a iniciar la comparación.
- length1
- Int32
Número de caracteres consecutivos de string1 que se van a comparar.
- string2
- String
Segunda cadena que se va a comparar.
- offset2
- Int32
Índice de base cero del carácter de string2 donde se va a iniciar la comparación.
- length2
- Int32
Número de caracteres consecutivos de string2 que se van a comparar.
- options
- CompareOptions
Valor que define cómo deben compararse los parámetros string1 y string2.
options es el valor de la enumeración Ordinal usado de forma aislada, o una combinación bit a bit de uno o varios de los valores siguientes: IgnoreCase, IgnoreSymbols, IgnoreNonSpace, IgnoreWidth, IgnoreKanaType y StringSort.
Devoluciones
Entero de 32 bits con signo que indica la relación léxica que existe entre los dos términos de una comparación.
| Valor | Condición |
|---|---|
| cero | Las dos cadenas son iguales. |
| menor que cero | La sección especificada de string1 es menor que la sección especificada de string2.
|
| mayor que cero | La sección especificada de string1 es mayor que la sección especificada de string2.
|
Excepciones
offset1 o length1 u offset2 o length2 es menor que cero.
O bien
offset1 es igual o mayor que el número de caracteres de string1.
O bien
offset2 es igual o mayor que el número de caracteres de string2.
O bien
length1 es mayor que el número de caracteres desde offset1 hasta el final de string1.
O bien
length2 es mayor que el número de caracteres desde offset2 hasta el final de string2.
options contiene un valor de CompareOptions no válido.
Ejemplos
En el ejemplo siguiente se comparan partes de dos cadenas con una configuración diferente CompareOptions .
using namespace System;
using namespace System::Globalization;
int main()
{
// Defines the strings to compare.
String^ myStr1 = "My Uncle Bill's clients";
String^ myStr2 = "My uncle bills clients";
// Creates a CompareInfo that uses the InvariantCulture.
CompareInfo^ myComp = CultureInfo::InvariantCulture->CompareInfo;
// Compares two strings using myComp.
Console::WriteLine( "Comparing \"{0}\" and \"{1}\"", myStr1->Substring( 3, 10 ), myStr2->Substring( 3, 10 ) );
Console::WriteLine( " With no CompareOptions : {0}", myComp->Compare( myStr1, 3, 10, myStr2, 3, 10 ) );
Console::WriteLine( " With None : {0}", myComp->Compare( myStr1, 3, 10, myStr2, 3, 10, CompareOptions::None ) );
Console::WriteLine( " With Ordinal : {0}", myComp->Compare( myStr1, 3, 10, myStr2, 3, 10, CompareOptions::Ordinal ) );
Console::WriteLine( " With StringSort : {0}", myComp->Compare( myStr1, 3, 10, myStr2, 3, 10, CompareOptions::StringSort ) );
Console::WriteLine( " With IgnoreCase : {0}", myComp->Compare( myStr1, 3, 10, myStr2, 3, 10, CompareOptions::IgnoreCase ) );
Console::WriteLine( " With IgnoreSymbols : {0}", myComp->Compare( myStr1, 3, 10, myStr2, 3, 10, CompareOptions::IgnoreSymbols ) );
Console::WriteLine( " With IgnoreCase and IgnoreSymbols : {0}", myComp->Compare( myStr1, 3, 10, myStr2, 3, 10, static_cast<CompareOptions>(CompareOptions::IgnoreCase | CompareOptions::IgnoreSymbols) ) );
}
/*
This code produces the following output.
Comparing "Uncle Bill" and "uncle bill"
With no CompareOptions : 1
With None : 1
With Ordinal : -32
With StringSort : 1
With IgnoreCase : 0
With IgnoreSymbols : 1
With IgnoreCase and IgnoreSymbols : 0
*/
using System;
using System.Globalization;
public class SamplesCompareInfo {
public static void Main() {
// Defines the strings to compare.
String myStr1 = "My Uncle Bill's clients";
String myStr2 = "My uncle bills clients";
// Creates a CompareInfo that uses the InvariantCulture.
CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo;
// Compares two strings using myComp.
Console.WriteLine( "Comparing \"{0}\" and \"{1}\"", myStr1.Substring( 3, 10 ), myStr2.Substring( 3, 10 ) );
Console.WriteLine( " With no CompareOptions : {0}", myComp.Compare( myStr1, 3, 10, myStr2, 3, 10 ) );
Console.WriteLine( " With None : {0}", myComp.Compare( myStr1, 3, 10, myStr2, 3, 10, CompareOptions.None ) );
Console.WriteLine( " With Ordinal : {0}", myComp.Compare( myStr1, 3, 10, myStr2, 3, 10, CompareOptions.Ordinal ) );
Console.WriteLine( " With StringSort : {0}", myComp.Compare( myStr1, 3, 10, myStr2, 3, 10, CompareOptions.StringSort ) );
Console.WriteLine( " With IgnoreCase : {0}", myComp.Compare( myStr1, 3, 10, myStr2, 3, 10, CompareOptions.IgnoreCase ) );
Console.WriteLine( " With IgnoreSymbols : {0}", myComp.Compare( myStr1, 3, 10, myStr2, 3, 10, CompareOptions.IgnoreSymbols ) );
Console.WriteLine( " With IgnoreCase and IgnoreSymbols : {0}", myComp.Compare( myStr1, 3, 10, myStr2, 3, 10, CompareOptions.IgnoreCase | CompareOptions.IgnoreSymbols ) );
}
}
/*
This code produces the following output.
Comparing "Uncle Bill" and "uncle bill"
With no CompareOptions : 1
With None : 1
With Ordinal : -32
With StringSort : 1
With IgnoreCase : 0
With IgnoreSymbols : 1
With IgnoreCase and IgnoreSymbols : 0
*/
Imports System.Globalization
Public Class SamplesCompareInfo
Public Shared Sub Main()
' Defines the strings to compare.
Dim myStr1 As [String] = "My Uncle Bill's clients"
Dim myStr2 As [String] = "My uncle bills clients"
' Creates a CompareInfo that uses the InvariantCulture.
Dim myComp As CompareInfo = CultureInfo.InvariantCulture.CompareInfo
' Compares two strings using myComp.
Console.WriteLine("Comparing ""{0}"" and ""{1}""", myStr1.Substring(3, 10), myStr2.Substring(3, 10))
Console.WriteLine(" With no CompareOptions : {0}", myComp.Compare(myStr1, 3, 10, myStr2, 3, 10))
Console.WriteLine(" With None : {0}", myComp.Compare(myStr1, 3, 10, myStr2, 3, 10, CompareOptions.None))
Console.WriteLine(" With Ordinal : {0}", myComp.Compare(myStr1, 3, 10, myStr2, 3, 10, CompareOptions.Ordinal))
Console.WriteLine(" With StringSort : {0}", myComp.Compare(myStr1, 3, 10, myStr2, 3, 10, CompareOptions.StringSort))
Console.WriteLine(" With IgnoreCase : {0}", myComp.Compare(myStr1, 3, 10, myStr2, 3, 10, CompareOptions.IgnoreCase))
Console.WriteLine(" With IgnoreSymbols : {0}", myComp.Compare(myStr1, 3, 10, myStr2, 3, 10, CompareOptions.IgnoreSymbols))
Console.WriteLine(" With IgnoreCase and IgnoreSymbols : {0}", myComp.Compare(myStr1, 3, 10, myStr2, 3, 10, CompareOptions.IgnoreCase Or CompareOptions.IgnoreSymbols))
End Sub
End Class
'This code produces the following output.
'
'Comparing "Uncle Bill" and "uncle bill"
' With no CompareOptions : 1
' With None : 1
' With Ordinal : -32
' With StringSort : 1
' With IgnoreCase : 0
' With IgnoreSymbols : 1
' With IgnoreCase and IgnoreSymbols : 0
Comentarios
Si una decisión de seguridad depende de una comparación de cadenas o un cambio de caso, debe usar la InvariantCulture propiedad para asegurarse de que el comportamiento sea coherente independientemente de la configuración de referencia cultural del sistema operativo.
Nota
Cuando sea posible, debe llamar a métodos de comparación de cadenas que tengan un parámetro de tipo CompareOptions para especificar el tipo de comparación esperado. Como regla general, use opciones lingüísticas (mediante la referencia cultural actual) para comparar cadenas mostradas en la interfaz de usuario y especificar Ordinal o OrdinalIgnoreCase para comparaciones de seguridad.
Notas a los autores de las llamadas
Los juegos de caracteres incluyen caracteres que se pueden pasar por alto. El Compare(String, Int32, Int32, String, Int32, Int32, CompareOptions) método no tiene en cuenta estos caracteres cuando realiza una comparación que distingue la referencia cultural. Para reconocer caracteres ignorables en la comparación, proporcione un valor de Ordinal o OrdinalIgnoreCase para el options parámetro .
Consulte también
Se aplica a
.NET 9 y otras versiones
| Producto | Versiones |
|---|---|
| .NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
| .NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
| .NET Standard | 1.0, 1.1, 1.2, 1.3, 1.4, 1.6, 2.0, 2.1 |
| UWP | 10.0 |
Comentarios de .NET
.NET es un proyecto de código abierto. Seleccione un vínculo para proporcionar comentarios: