String.EndsWith Méthode

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Détermine si la fin de cette instance de chaîne correspond à une chaîne spécifiée.

Surcharges

EndsWith(String, Boolean, CultureInfo)	Détermine si la fin 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.
EndsWith(String, StringComparison)	Détermine si la fin 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.
EndsWith(Char)	Détermine si la fin de cette instance de chaîne correspond au caractère spécifié.
EndsWith(String)	Détermine si la fin de cette instance de chaîne correspond à la chaîne spécifiée.

EndsWith(String, Boolean, CultureInfo)

Source:

String.Comparison.cs

Détermine si la fin 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 EndsWith (string value, bool ignoreCase, System.Globalization.CultureInfo? culture);

Paramètres

value

String

Chaîne à comparer à la sous-chaîne à la fin de cette instance.

ignoreCase

Boolean

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

culture

CultureInfo

Informations culturelles déterminant comment cette instance et value sont comparées. Si culture est null, la culture actuelle est utilisée.

Retours

Boolean

true si le paramètre value correspond à la fin de cette instance ; sinon, false.

Exceptions

ArgumentNullException

value a la valeur null.

Exemples

L’exemple suivant détermine si une chaîne se produit à la fin d’une autre chaîne. La EndsWith 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.EndsWith(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 xyzARing = "xyz" + "\u0061\u030a";

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

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

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

        Console.WriteLine("Case insensitive:");
        result = xyzARing.EndsWith(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 = xyzARing.EndsWith(capitalARing, false, ci);
        Console.WriteLine(msg3, result);

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

/*
This code example produces the following results (for en-us culture):

Search for the target string "Å" in the string "xyza°".

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 à la fin de cette chaîne qui a la même longueur que value, et retourne une valeur qui indique si elles sont égales. Pour être égal, value doit être une référence à ce même instance ou correspondre à la fin de cette chaîne.

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

Voir aussi

• InvariantCulture

EndsWith(String, StringComparison)

Source:

String.Comparison.cs

Détermine si la fin 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 EndsWith (string value, StringComparison comparisonType);

Paramètres

value

String

Chaîne à comparer à la sous-chaîne à la fin de cette instance.

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 le paramètre value correspond à la fin de cette instance ; sinon, false.

Exceptions

ArgumentNullException

value a la valeur null.

ArgumentException

comparisonType n’est pas une valeur StringComparison.

Exemples

L’exemple suivant détermine si une chaîne se termine par une sous-chaîne particulière. 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.

C#

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

using System;
using System.Threading;

class Sample 
{
    public static void Main() 
    {
        string intro = "Determine whether a string ends with another string, " +
                   "using\n  different values of StringComparison.";

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

        Console.WriteLine(intro);

        // Display the current culture because the culture-specific comparisons
        // can produce different results with different cultures.
        Console.WriteLine("The current culture is {0}.\n", 
                       Thread.CurrentThread.CurrentCulture.Name);
        
        // Determine whether three versions of the letter I are equal to each other. 
        foreach (StringComparison sc in scValues)
        {
            Console.WriteLine("StringComparison.{0}:", sc);
            Test("abcXYZ", "XYZ", sc);
            Test("abcXYZ", "xyz", sc);
            Console.WriteLine();
        }
    }

    protected static void Test(string x, string y, StringComparison comparison)
    {
        string resultFmt = "\"{0}\" {1} with \"{2}\".";
        string result = "does not end";

        if (x.EndsWith(y, comparison))
            result = "ends";
        Console.WriteLine(resultFmt, x, result, y);
    }
}

/*
This code example produces the following results:

Determine whether a string ends with another string, using
  different values of StringComparison.
The current culture is en-US.

StringComparison.CurrentCulture:
"abcXYZ" ends with "XYZ".
"abcXYZ" does not end with "xyz".

StringComparison.CurrentCultureIgnoreCase:
"abcXYZ" ends with "XYZ".
"abcXYZ" ends with "xyz".

StringComparison.InvariantCulture:
"abcXYZ" ends with "XYZ".
"abcXYZ" does not end with "xyz".

StringComparison.InvariantCultureIgnoreCase:
"abcXYZ" ends with "XYZ".
"abcXYZ" ends with "xyz".

StringComparison.Ordinal:
"abcXYZ" ends with "XYZ".
"abcXYZ" does not end with "xyz".

StringComparison.OrdinalIgnoreCase:
"abcXYZ" ends with "XYZ".
"abcXYZ" ends with "xyz".

*/

Remarques

La EndsWith méthode compare le paramètre à la value sous-chaîne à la fin 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 à la fin de cette chaîne. Le type de comparaison effectué par la EndsWith méthode dépend de la valeur du comparisonType paramètre.

Voir aussi

• StringComparison

EndsWith(Char)

Source:

String.Comparison.cs

Détermine si la fin de cette instance de chaîne correspond au caractère spécifié.

C#

public bool EndsWith (char value);

Paramètres

value

Char

Caractère à comparer au caractère à la fin de cette instance.

Retours

Boolean

true si value correspond à la fin de cette instance ; sinon, false.

Remarques

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

EndsWith(String)

Source:

String.Comparison.cs

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

C#

public bool EndsWith (string value);

Paramètres

value

String

Chaîne à comparer à la sous-chaîne à la fin de cette instance.

Retours

Boolean

true si value correspond à la fin de cette instance ; sinon, false.

Exceptions

ArgumentNullException

value a la valeur null.

Exemples

L’exemple suivant indique si chaque chaîne d’un tableau se termine par un point (« . »).

C#

using System;

public class Example
{
   public static void Main()
   {
      String[] strings = { "This is a string.", "Hello!", "Nothing.", 
                           "Yes.", "randomize" };
      foreach (var value in strings) {
         bool endsInPeriod = value.EndsWith(".");
         Console.WriteLine("'{0}' ends in a period: {1}", 
                           value, endsInPeriod);
      }                            
   }
}
// The example displays the following output:
//       'This is a string.' ends in a period: True
//       'Hello!' ends in a period: False
//       'Nothing.' ends in a period: True
//       'Yes.' ends in a period: True
//       'randomize' ends in a period: False

L’exemple suivant définit une StripEndTags méthode qui utilise la EndsWith(String) méthode pour supprimer les balises de fin HTML de la fin d’une ligne. Notez que la StripEndTags méthode est appelée de manière récursive pour s’assurer que plusieurs balises de fin HTML à la fin de la ligne sont supprimées.

C#

using System;

public class EndsWithTest {
    public static void Main() {

        // process an input file that contains html tags.
        // this sample checks for multiple tags at the end of the line, rather than simply
        // removing the last one.
        // note: HTML markup tags always end in a greater than symbol (>).

        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 ends with a greater than symbol, it should not be modified>" };

        Console.WriteLine("The following lists the items before the ends have been stripped:");
        Console.WriteLine("-----------------------------------------------------------------");

        // print out the initial array of strings
        foreach ( string s in strSource )
            Console.WriteLine( s );

        Console.WriteLine();

        Console.WriteLine("The following lists the items after the ends have been stripped:");
        Console.WriteLine("----------------------------------------------------------------");

        // print out the array of strings
        foreach (var s in strSource)
            Console.WriteLine(StripEndTags(s));
    }

    private static string StripEndTags( string item ) {

        bool found = false;

        // try to find a tag at the end of the line using EndsWith
        if (item.Trim().EndsWith(">")) {

            // now search for the opening tag...
            int lastLocation = item.LastIndexOf( "</" );

            // remove the identified section, if it is a valid region
            if ( lastLocation >= 0 ) {
                found = true;
                item =  item.Substring( 0, lastLocation );
            }
        }

        if (found)
           item = StripEndTags(item);

        return item;
    }
}
// The example displays the following output:
//    The following lists the items before the ends have been stripped:
//    -----------------------------------------------------------------
//    <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 ends with a greater than symbol, it should not be modified>
//
//    The following lists the items after the ends have been stripped:
//    ----------------------------------------------------------------
//    <b>This is bold text
//    <H1>This is large Text
//    <b><i><font color=green>This has multiple tags
//    <b>This has <i>embedded</i> tags.
//    This line simply ends with a greater than symbol, it should not be modified>

Remarques

Cette méthode se compare value à la sous-chaîne à la fin 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 référence à ce même instance ou correspondre à la fin 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 se termine 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 surcharge de méthode EndsWith(String, StringComparison) 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

• StartsWith(String)
• Compare(String, String)