String.StartsWith Méthode

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Surcharges

StartsWith(String, Boolean, CultureInfo)	Détermine si le début de cette instance de chaîne correspond à la chaîne spécifiée quand elle est comparée à l'aide de la culture spécifiée.
StartsWith(String, StringComparison)	Détermine si le début de cette instance de chaîne correspond à la chaîne spécifiée quand elle est comparée à l'aide de l'option spécifiée.
StartsWith(Char)	Détermine si cette instance de chaîne commence par le caractère spécifié.
StartsWith(String)	Détermine si le début de cette instance de chaîne correspond à la chaîne spécifiée.

StartsWith(String, Boolean, CultureInfo)

Source:

String.Comparison.cs

Détermine si le début de cette instance de chaîne correspond à la chaîne spécifiée quand elle est comparée à l'aide de la culture spécifiée.

C#

public bool StartsWith (string value, bool ignoreCase, System.Globalization.CultureInfo? culture);

Paramètres

value

String

Chaîne à comparer.

ignoreCase

Boolean

true pour ignorer la casse pendant la comparaison, sinon, false.

culture

CultureInfo

Informations culturelles déterminant le mode de comparaison entre cette chaîne et value. Si culture est null, la culture actuelle est utilisée.

Retours

Boolean

true si le paramètre value correspond au début de cette chaîne ; sinon, false.

Exceptions

ArgumentNullException

value a la valeur null.

Exemples

L’exemple suivant détermine si une chaîne se produit au début d’une autre chaîne. La StartsWith méthode est appelée plusieurs fois en utilisant la sensibilité à la casse, l’insensibilité de la casse et différentes cultures qui influencent les résultats de la recherche.

C#

// This code example demonstrates the 
// System.String.StartsWith(String, ..., CultureInfo) method.

using System;
using System.Threading;
using System.Globalization;

class Sample 
{
    public static void Main() 
    {
    string msg1 = "Search for the target string \"{0}\" in the string \"{1}\".\n";
    string msg2 = "Using the {0} - \"{1}\" culture:";
    string msg3 = "  The string to search ends with the target string: {0}";
    bool result = false;
    CultureInfo ci;

// Define a target string to search for.
// U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
    string capitalARing = "\u00c5";

// Define a string to search. 
// The result of combining the characters LATIN SMALL LETTER A and COMBINING 
// RING ABOVE (U+0061, U+030a) is linguistically equivalent to the character 
// LATIN SMALL LETTER A WITH RING ABOVE (U+00e5).
    string aRingXYZ = "\u0061\u030a" + "xyz";

// Clear the screen and display an introduction.
    Console.Clear();

// Display the string to search for and the string to search.
    Console.WriteLine(msg1, capitalARing, aRingXYZ);

// Search using English-United States culture.
    ci = new CultureInfo("en-US");
    Console.WriteLine(msg2, ci.DisplayName, ci.Name);

    Console.WriteLine("Case sensitive:");
    result = aRingXYZ.StartsWith(capitalARing, false, ci);
    Console.WriteLine(msg3, result);

    Console.WriteLine("Case insensitive:");
    result = aRingXYZ.StartsWith(capitalARing, true, ci);
    Console.WriteLine(msg3, result);
    Console.WriteLine();

// Search using Swedish-Sweden culture.
    ci = new CultureInfo("sv-SE");
    Console.WriteLine(msg2, ci.DisplayName, ci.Name);

    Console.WriteLine("Case sensitive:");
    result = aRingXYZ.StartsWith(capitalARing, false, ci);
    Console.WriteLine(msg3, result);

    Console.WriteLine("Case insensitive:");
    result = aRingXYZ.StartsWith(capitalARing, true, ci);
    Console.WriteLine(msg3, result);
    }
}

/*
Note: This code example was executed on a console whose user interface 
culture is "en-US" (English-United States).

Search for the target string "Å" in the string "a°xyz".

Using the English (United States) - "en-US" culture:
Case sensitive:
  The string to search ends with the target string: False
Case insensitive:
  The string to search ends with the target string: True

Using the Swedish (Sweden) - "sv-SE" culture:
Case sensitive:
  The string to search ends with the target string: False
Case insensitive:
  The string to search ends with the target string: False

*/

Remarques

Cette méthode compare le paramètre à la value sous-chaîne au début de cette chaîne qui est de la même longueur que value, et retourne une valeur qui indique si elles sont égales. Pour être égal, value doit être une chaîne vide (String.Empty), doit être une référence à ce même instance ou doit correspondre au début de cette instance.

Cette méthode effectue une comparaison à l’aide de la casse et de la culture spécifiées.

StartsWith(String, StringComparison)

Source:

String.Comparison.cs

Détermine si le début de cette instance de chaîne correspond à la chaîne spécifiée quand elle est comparée à l'aide de l'option spécifiée.

C#

public bool StartsWith (string value, StringComparison comparisonType);

Paramètres

value

String

Chaîne à comparer.

comparisonType

StringComparison

Une des valeurs d'énumération qui détermine le mode de comparaison entre cette chaîne et value.

Retours

Boolean

true si cette instance commence par value ; sinon, false.

Exceptions

ArgumentNullException

value a la valeur null.

ArgumentException

comparisonType n’est pas une valeur StringComparison.

Exemples

L’exemple suivant recherche la chaîne « the » au début d’une chaîne plus longue qui commence par le mot « The ». Comme le montre la sortie de l’exemple, un appel à la StartsWith(String, StringComparison) méthode qui effectue une comparaison qui ne respecte pas la culture, mais qui respecte la casse ne parvient pas à correspondre à la chaîne, tandis qu’un appel qui effectue une comparaison sans respect de la culture et de la casse correspond à la chaîne.

C#

using System;

public class Example
{
   public static void Main()
   {
      String title = "The House of the Seven Gables";
      String searchString = "the";
      StringComparison comparison = StringComparison.InvariantCulture;
      Console.WriteLine("'{0}':", title);
      Console.WriteLine("   Starts with '{0}' ({1:G} comparison): {2}",
                        searchString, comparison,
                        title.StartsWith(searchString, comparison));

      comparison = StringComparison.InvariantCultureIgnoreCase;
      Console.WriteLine("   Starts with '{0}' ({1:G} comparison): {2}",
                        searchString, comparison,
                        title.StartsWith(searchString, comparison));
   }
}
// The example displays the following output:
//       'The House of the Seven Gables':
//          Starts with 'the' (InvariantCulture comparison): False
//          Starts with 'the' (InvariantCultureIgnoreCase comparison): True

L’exemple suivant détermine si une chaîne commence par une sous-chaîne particulière. Il initialise un tableau de chaînes à deux dimensions. Le premier élément de la deuxième dimension contient une chaîne et le deuxième élément contient la chaîne à rechercher au début de la première chaîne. Les résultats sont affectés par le choix de la culture, si la casse est ignorée et si une comparaison ordinale est effectuée. Notez que lorsque la chaîne instance contient une ligature, les comparaisons sensibles à la culture avec ses caractères consécutifs correspondent correctement.

C#

using System;

public class Example
{
   public static void Main()
   {
      string[,] strings = { {"ABCdef", "abc" },                    
                            {"ABCdef", "abc" },  
                            {"œil","oe" },
                            { "læring}", "lae" } };
      for (int ctr1 = strings.GetLowerBound(0); ctr1 <= strings.GetUpperBound(0); ctr1++)
      {
            foreach (string cmpName in Enum.GetNames(typeof(StringComparison)))
            { 
               StringComparison strCmp = (StringComparison) Enum.Parse(typeof(StringComparison), 
                                                      cmpName);
               string instance = strings[ctr1, 0];
               string value = strings[ctr1, 1];
               Console.WriteLine("{0} starts with {1}: {2} ({3} comparison)", 
                                 instance, value, 
                                 instance.StartsWith(value, strCmp), 
                                 strCmp); 
            }
            Console.WriteLine();   
      }   
   }
}
// The example displays the following output:
//       ABCdef starts with abc: False (CurrentCulture comparison)
//       ABCdef starts with abc: True (CurrentCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (InvariantCulture comparison)
//       ABCdef starts with abc: True (InvariantCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (Ordinal comparison)
//       ABCdef starts with abc: True (OrdinalIgnoreCase comparison)
//       
//       ABCdef starts with abc: False (CurrentCulture comparison)
//       ABCdef starts with abc: True (CurrentCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (InvariantCulture comparison)
//       ABCdef starts with abc: True (InvariantCultureIgnoreCase comparison)
//       ABCdef starts with abc: False (Ordinal comparison)
//       ABCdef starts with abc: True (OrdinalIgnoreCase comparison)
//       
//       œil starts with oe: True (CurrentCulture comparison)
//       œil starts with oe: True (CurrentCultureIgnoreCase comparison)
//       œil starts with oe: True (InvariantCulture comparison)
//       œil starts with oe: True (InvariantCultureIgnoreCase comparison)
//       œil starts with oe: False (Ordinal comparison)
//       œil starts with oe: False (OrdinalIgnoreCase comparison)
//       
//       læring} starts with lae: True (CurrentCulture comparison)
//       læring} starts with lae: True (CurrentCultureIgnoreCase comparison)
//       læring} starts with lae: True (InvariantCulture comparison)
//       læring} starts with lae: True (InvariantCultureIgnoreCase comparison)
//       læring} starts with lae: False (Ordinal comparison)
//       læring} starts with lae: False (OrdinalIgnoreCase comparison)

Remarques

La StartsWith méthode compare le paramètre à la value sous-chaîne au début de cette chaîne et retourne une valeur qui indique s’ils sont égaux. Pour être égal, value doit être une référence à cette même chaîne, doit être la chaîne vide («  »), ou doit correspondre au début de cette chaîne. Le type de comparaison effectué par la StartsWith méthode dépend de la valeur du comparisonType paramètre. La comparaison peut utiliser les conventions de la culture actuelle (StringComparison.CurrentCulture et StringComparison.CurrentCultureIgnoreCase) ou de la culture invariante (StringComparison.InvariantCulture et StringComparison.InvariantCultureIgnoreCase), ou elle peut consister en une comparaison caractère par caractère de points de code (StringComparison.Ordinal ou StringComparison.OrdinalIgnoreCase). La comparaison peut également respecter la casse (StringComparison.CurrentCulture, StringComparison.InvariantCultureou StringComparison.Ordinal) ou ignorer la casse (StringComparison.CurrentCultureIgnoreCase, StringComparison.InvariantCultureIgnoreCase, StringComparison.OrdinalIgnoreCase).

Voir aussi

• StringComparison

StartsWith(Char)

Source:

String.Comparison.cs

Détermine si cette instance de chaîne commence par le caractère spécifié.

C#

public bool StartsWith (char value);

Paramètres

value

Char

Caractère à comparer.

Retours

Boolean

true si value correspond au début de cette instance ; sinon, false.

Remarques

Cette méthode effectue une comparaison ordinale (respectant la casse et ne respectant pas la culture).

StartsWith(String)

Source:

String.Comparison.cs

Détermine si le début de cette instance de chaîne correspond à la chaîne spécifiée.

C#

public bool StartsWith (string value);

Paramètres

value

String

Chaîne à comparer.

Retours

Boolean

true si value correspond au début de cette instance ; sinon, false.

Exceptions

ArgumentNullException

value a la valeur null.

Exemples

L’exemple suivant définit une StripStartTags méthode qui utilise la StartsWith(String) méthode pour supprimer les balises de début HTML du début d’une chaîne. Notez que la StripStartTags méthode est appelée de manière récursive pour garantir que plusieurs balises de début HTML au début de la ligne sont supprimées. L’exemple ne supprime pas les balises HTML incorporées dans une chaîne.

C#

using System;

public class Example
{
   public static void Main() {
      string [] strSource = { "<b>This is bold text</b>", "<H1>This is large Text</H1>",
                "<b><i><font color=green>This has multiple tags</font></i></b>",
                "<b>This has <i>embedded</i> tags.</b>",
                "<This line simply begins with a lesser than symbol, it should not be modified" };

      // Display the initial string array.
      Console.WriteLine("The original strings:");
      Console.WriteLine("---------------------");
      foreach (var s in strSource)
         Console.WriteLine(s);
      Console.WriteLine();

      Console.WriteLine("Strings after starting tags have been stripped:");
      Console.WriteLine("-----------------------------------------------");

      // Display the strings with starting tags removed.
     foreach (var s in strSource)
        Console.WriteLine(StripStartTags(s));
   }

   private static string StripStartTags(string item)
   {
      // Determine whether a tag begins the string.
      if (item.Trim().StartsWith("<")) {
         // Find the closing tag.
         int lastLocation = item.IndexOf( ">" );
         // Remove the tag.
         if (lastLocation >= 0) {
            item =  item.Substring( lastLocation + 1 );

            // Remove any additional starting tags.
            item = StripStartTags(item);
         }
      }

      return item;
   }
}
// The example displays the following output:
//    The original strings:
//    ---------------------
//    <b>This is bold text</b>
//    <H1>This is large Text</H1>
//    <b><i><font color = green>This has multiple tags</font></i></b>
//    <b>This has <i>embedded</i> tags.</b>
//    <This line simply begins with a lesser than symbol, it should not be modified
//
//    Strings after starting tags have been stripped:
//    -----------------------------------------------
//    This is bold text</b>
//    This is large Text</H1>
//    This has multiple tags</font></i></b>
//    This has <i>embedded</i> tags.</b>
//    <This line simply begins with a lesser than symbol, it should not be modified

Remarques

Cette méthode se compare value à la sous-chaîne au début de cette instance qui est de la même longueur que value, et retourne une indication si elles sont égales. Pour être égal, value doit être une chaîne vide (String.Empty), doit être une référence à ce même instance ou doit correspondre au début de cette instance.

Cette méthode effectue une comparaison de mots (respectant la casse et la culture) à l’aide de la culture actuelle.

Notes pour les appelants

Comme expliqué dans Meilleures pratiques pour l’utilisation de chaînes, nous vous recommandons d’éviter d’appeler des méthodes de comparaison de chaînes qui remplacent des valeurs par défaut et d’appeler plutôt des méthodes qui nécessitent des paramètres à spécifier explicitement. Pour déterminer si une chaîne commence par une sous-chaîne particulière à l’aide des règles de comparaison de chaînes de la culture actuelle, signalez explicitement votre intention en appelant la StartsWith(String, StringComparison) surcharge de méthode avec une valeur de CurrentCulture pour son comparisonType paramètre. Si vous n’avez pas besoin d’une comparaison linguistique, envisagez d’utiliser Ordinal.

Voir aussi

• EndsWith(String)