Lire en anglais

Partager via


String.CompareTo Méthode

Définition

Compare cette instance à un objet spécifié ou String et retourne un entier qui indique si cette instance précède, suit ou apparaît à la même position dans l'ordre de tri que l'objet spécifié ou String.

Surcharges

CompareTo(Object)

Compare cette instance avec un Object spécifié et indique si cette instance précède, suit ou apparaît à la même position dans l'ordre de tri que le Object spécifié.

CompareTo(String)

Compare cette instance avec un objet String spécifié et indique si cette instance précède, suit ou apparaît à la même position dans l'ordre de tri que la chaîne spécifiée.

Remarques

Les deux surcharges de la CompareTo méthode effectuent une comparaison respectant la culture et la casse. Vous ne pouvez pas utiliser cette méthode pour effectuer des comparaisons ordinales ou non sensibles à la culture. Pour plus de clarté du code, nous vous recommandons d’éviter la CompareTo méthode et d’appeler la méthode à la Compare place.

CompareTo(Object)

Source:
String.Comparison.cs
Source:
String.Comparison.cs
Source:
String.Comparison.cs

Compare cette instance avec un Object spécifié et indique si cette instance précède, suit ou apparaît à la même position dans l'ordre de tri que le Object spécifié.

public int CompareTo (object? value);
public int CompareTo (object value);

Paramètres

value
Object

Objet qui prend pour valeur String.

Retours

Entier signé 32 bits qui indique si cette instance précède, suit ou apparaît dans la même position dans l'ordre de tri que le paramètre value.

Value Condition
Inférieure à zéro Cette instance précède value.
Zéro Cette instance a la même position dans l'ordre de tri que value.
Supérieure à zéro Cette instance suit value.

-ou-

value a la valeur null.

Implémente

Exceptions

value n’est pas un String.

Exemples

L’exemple suivant utilise la CompareTo méthode avec un Object. Étant donné qu’elle tente de comparer un String instance à un TestClass objet, la méthode lève un ArgumentException.

using System;

public class TestClass
{}

public class Example
{
   public static void Main()
   {
      var test = new TestClass();
      Object[] objectsToCompare = { test, test.ToString(), 123,
                                    123.ToString(), "some text",
                                    "Some Text" };
      string s = "some text";
      foreach (var objectToCompare in objectsToCompare) {
         try {
            int i = s.CompareTo(objectToCompare);
            Console.WriteLine("Comparing '{0}' with '{1}': {2}",
                              s, objectToCompare, i);
         }
         catch (ArgumentException) {
            Console.WriteLine("Bad argument: {0} (type {1})",
                              objectToCompare,
                              objectToCompare.GetType().Name);
         }
      }
   }
}
// The example displays the following output:
//    Bad argument: TestClass (type TestClass)
//    Comparing 'some text' with 'TestClass': -1
//    Bad argument: 123 (type Int32)
//    Comparing 'some text' with '123': 1
//    Comparing 'some text' with 'some text': 0
//    Comparing 'some text' with 'Some Text': -1

Remarques

value doit être un String objet .

Attention

La CompareTo méthode a été conçue principalement pour être utilisée dans les opérations de tri ou d’alphabetisation. Il ne doit pas être utilisé lorsque l’objectif principal de l’appel de méthode est de déterminer si deux chaînes sont équivalentes. Pour déterminer si deux chaînes sont équivalentes, appelez la Equals méthode .

Cette méthode effectue une comparaison de mots (respectant la casse et la culture) à l’aide de la culture actuelle. Pour plus d’informations sur les tris de mots, de chaînes et ordinaux, consultez System.Globalization.CompareOptions.

Pour plus d’informations sur le comportement de cette méthode, consultez la section Remarques de la String.Compare(String, String) méthode .

Notes pour les appelants

Les jeux de caractères incluent les caractères ignorables. La CompareTo(Object) méthode ne prend pas en compte ces caractères lorsqu’elle effectue une comparaison sensible à la culture. Par exemple, si le code suivant est exécuté sur .NET Framework 4 ou version ultérieure, une comparaison de « animal » avec « ani-mal » (à l’aide d’un trait d’union doux ou U+00AD) indique que les deux chaînes sont équivalentes.

using System;

public class Example
{
   public static void Main()
   {
      string s1 = "ani\u00ADmal";
      object o1 = "animal";
      
      Console.WriteLine("Comparison of '{0}' and '{1}': {2}", 
                        s1, o1, s1.CompareTo(o1));
   }
}
// The example displays the following output:
//       Comparison of 'ani-mal' and 'animal': 0

Pour reconnaître les caractères ignorés dans une comparaison de chaînes, appelez la CompareOrdinal(String, String) méthode .

Voir aussi

S’applique à

.NET 9 et autres versions
Produit Versions
.NET 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 2.0, 2.1

CompareTo(String)

Source:
String.Comparison.cs
Source:
String.Comparison.cs
Source:
String.Comparison.cs

Compare cette instance avec un objet String spécifié et indique si cette instance précède, suit ou apparaît à la même position dans l'ordre de tri que la chaîne spécifiée.

public int CompareTo (string strB);
public int CompareTo (string? strB);

Paramètres

strB
String

Chaîne à comparer à cette instance.

Retours

Entier signé 32 bits qui indique si cette instance précède, suit ou apparaît dans la même position dans l'ordre de tri que le paramètre strB.

Value Condition
Inférieure à zéro Cette instance précède strB.
Zéro Cette instance a la même position dans l'ordre de tri que strB.
Supérieure à zéro Cette instance suit strB.

-ou-

strB a la valeur null.

Implémente

Exemples

L’exemple suivant utilise la CompareTo méthode pour comparer la chaîne actuelle instance à une autre chaîne.

using System;

public class Example
{
   public static void Main()
   {
      string strFirst = "Goodbye";
      string strSecond = "Hello";
      string strThird = "a small string";
      string strFourth = "goodbye";

      // Compare a string to itself.
      Console.WriteLine(CompareStrings(strFirst, strFirst));

      Console.WriteLine(CompareStrings(strFirst, strSecond));
      Console.WriteLine(CompareStrings(strFirst, strThird));

      // Compare a string to another string that varies only by case.
      Console.WriteLine(CompareStrings(strFirst, strFourth));
      Console.WriteLine(CompareStrings(strFourth, strFirst));
   }

   private static string CompareStrings( string str1, string str2 )
   {
      // Compare the values, using the CompareTo method on the first string.
      int cmpVal = str1.CompareTo(str2);

       if (cmpVal == 0) // The strings are the same.
         return "The strings occur in the same position in the sort order.";
      else if (cmpVal < 0)
         return "The first string precedes the second in the sort order.";
      else
         return "The first string follows the second in the sort order.";
    }
}
// The example displays the following output:
//       The strings occur in the same position in the sort order.
//       The first string precedes the second in the sort order.
//       The first string follows the second in the sort order.
//       The first string follows the second in the sort order.
//       The first string precedes the second in the sort order.

L’exemple suivant illustre les versions génériques et non génériques de la méthode CompareTo pour plusieurs types valeur et référence.

// This example demonstrates the generic and non-generic versions of the
// CompareTo method for several base types.
// The non-generic version takes a parameter of type Object, while the generic
// version takes a type-specific parameter, such as Boolean, Int32, or Double.

using System;

class Sample
{
    public static void Main()
    {
    string    nl = Environment.NewLine;
    string    msg = "{0}The following is the result of using the generic and non-generic{0}" +
                    "versions of the CompareTo method for several base types:{0}";

    DateTime  now = DateTime.Now;
// Time span = 11 days, 22 hours, 33 minutes, 44 seconds
    TimeSpan  tsX = new TimeSpan(11, 22, 33, 44);
// Version = 1.2.333.4
    Version   versX = new Version("1.2.333.4");
// Guid = CA761232-ED42-11CE-BACD-00AA0057B223
    Guid      guidX = new Guid("{CA761232-ED42-11CE-BACD-00AA0057B223}");

    Boolean  a1 = true,  a2 = true;
    Byte     b1 = 1,     b2 = 1;
    Int16    c1 = -2,    c2 = 2;
    Int32    d1 = 3,     d2 = 3;
    Int64    e1 = 4,     e2 = -4;
    Decimal  f1 = -5.5m, f2 = 5.5m;
    Single   g1 = 6.6f,  g2 = 6.6f;
    Double   h1 = 7.7d,  h2 = -7.7d;
    Char     i1 = 'A',   i2 = 'A';
    String   j1 = "abc", j2 = "abc";
    DateTime k1 = now,   k2 = now;
    TimeSpan l1 = tsX,   l2 = tsX;
    Version  m1 = versX, m2 = new Version("2.0");
    Guid     n1 = guidX, n2 = guidX;

// The following types are not CLS-compliant.
    SByte    w1 = 8,     w2 = 8;
    UInt16   x1 = 9,     x2 = 9;
    UInt32   y1 = 10,    y2 = 10;
    UInt64   z1 = 11,    z2 = 11;
//
    Console.WriteLine(msg, nl);
    try
        {
// The second and third Show method call parameters are automatically boxed because
// the second and third Show method declaration arguments expect type Object.

        Show("Boolean:  ", a1, a2, a1.CompareTo(a2), a1.CompareTo((Object)a2));
        Show("Byte:     ", b1, b2, b1.CompareTo(b2), b1.CompareTo((Object)b2));
        Show("Int16:    ", c1, c2, c1.CompareTo(c2), c1.CompareTo((Object)c2));
        Show("Int32:    ", d1, d2, d1.CompareTo(d2), d1.CompareTo((Object)d2));
        Show("Int64:    ", e1, e2, e1.CompareTo(e2), e1.CompareTo((Object)e2));
        Show("Decimal:  ", f1, f2, f1.CompareTo(f2), f1.CompareTo((Object)f2));
        Show("Single:   ", g1, g2, g1.CompareTo(g2), g1.CompareTo((Object)g2));
        Show("Double:   ", h1, h2, h1.CompareTo(h2), h1.CompareTo((Object)h2));
        Show("Char:     ", i1, i2, i1.CompareTo(i2), i1.CompareTo((Object)i2));
        Show("String:   ", j1, j2, j1.CompareTo(j2), j1.CompareTo((Object)j2));
        Show("DateTime: ", k1, k2, k1.CompareTo(k2), k1.CompareTo((Object)k2));
        Show("TimeSpan: ", l1, l2, l1.CompareTo(l2), l1.CompareTo((Object)l2));
        Show("Version:  ", m1, m2, m1.CompareTo(m2), m1.CompareTo((Object)m2));
        Show("Guid:     ", n1, n2, n1.CompareTo(n2), n1.CompareTo((Object)n2));
//
        Console.WriteLine("{0}The following types are not CLS-compliant:", nl);
        Show("SByte:    ", w1, w2, w1.CompareTo(w2), w1.CompareTo((Object)w2));
        Show("UInt16:   ", x1, x2, x1.CompareTo(x2), x1.CompareTo((Object)x2));
        Show("UInt32:   ", y1, y2, y1.CompareTo(y2), y1.CompareTo((Object)y2));
        Show("UInt64:   ", z1, z2, z1.CompareTo(z2), z1.CompareTo((Object)z2));
        }
    catch (Exception e)
        {
        Console.WriteLine(e);
        }
    }

    public static void Show(string caption, Object var1, Object var2,
                            int resultGeneric, int resultNonGeneric)
    {
    string relation;

    Console.Write(caption);
    if (resultGeneric == resultNonGeneric)
        {
        if      (resultGeneric < 0) relation = "less than";
        else if (resultGeneric > 0) relation = "greater than";
        else                        relation = "equal to";
        Console.WriteLine("{0} is {1} {2}", var1, relation, var2);
        }

// The following condition will never occur because the generic and non-generic
// CompareTo methods are equivalent.

    else
        {
        Console.WriteLine("Generic CompareTo = {0}; non-generic CompareTo = {1}",
                           resultGeneric, resultNonGeneric);
        }
   }
}
/*
This example produces the following results:

The following is the result of using the generic and non-generic versions of the
CompareTo method for several base types:

Boolean:  True is equal to True
Byte:     1 is equal to 1
Int16:    -2 is less than 2
Int32:    3 is equal to 3
Int64:    4 is greater than -4
Decimal:  -5.5 is less than 5.5
Single:   6.6 is equal to 6.6
Double:   7.7 is greater than -7.7
Char:     A is equal to A
String:   abc is equal to abc
DateTime: 12/1/2003 5:37:46 PM is equal to 12/1/2003 5:37:46 PM
TimeSpan: 11.22:33:44 is equal to 11.22:33:44
Version:  1.2.333.4 is less than 2.0
Guid:     ca761232-ed42-11ce-bacd-00aa0057b223 is equal to ca761232-ed42-11ce-bacd-00
aa0057b223

The following types are not CLS-compliant:
SByte:    8 is equal to 8
UInt16:   9 is equal to 9
UInt32:   10 is equal to 10
UInt64:   11 is equal to 11
*/

Remarques

Cette méthode effectue une comparaison de mots (respectant la casse et la culture) à l’aide de la culture actuelle. Pour plus d’informations sur les tris de mots, de chaînes et ordinaux, consultez System.Globalization.CompareOptions.

Attention

La CompareTo méthode a été conçue principalement pour être utilisée dans les opérations de tri ou d’alphabetisation. Il ne doit pas être utilisé lorsque l’objectif principal de l’appel de méthode est de déterminer si deux chaînes sont équivalentes. Pour déterminer si deux chaînes sont équivalentes, appelez la Equals méthode .

Pour plus d’informations sur le comportement de cette méthode, consultez la section Remarques de la Compare(String, String) méthode .

Cette méthode implémente l’interface System.IComparable<T> et fonctionne légèrement mieux que la String.CompareTo(Object) méthode, car elle n’a pas à déterminer si l’argument strB est un type valeur mutable qui doit être boxé, et elle n’a pas besoin de convertir son paramètre d’un Object en un String.

Notes pour les appelants

Les jeux de caractères incluent les caractères ignorables. La CompareTo(String) méthode ne prend pas en compte ces caractères lorsqu’elle effectue une comparaison sensible à la culture. Par exemple, si le code suivant est exécuté sur .NET Framework 4 ou version ultérieure, une comparaison de « animal » avec « ani-mal » (à l’aide d’un trait d’union doux ou U+00AD) indique que les deux chaînes sont équivalentes.

using System;

public class Example
{
   public static void Main()
   {
      string s1 = "ani\u00ADmal";
      string s2 = "animal";
      
      Console.WriteLine("Comparison of '{0}' and '{1}': {2}", 
                        s1, s2, s1.CompareTo(s2));
   }
}
// The example displays the following output:
//       Comparison of 'ani-mal' and 'animal': 0

Pour reconnaître les caractères ignorés dans une comparaison de chaînes, appelez la CompareOrdinal(String, String) méthode .

Voir aussi

S’applique à

.NET 9 et autres versions
Produit Versions
.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.5, 1.6, 2.0, 2.1
UWP 10.0