String.LastIndexOf Méthode

Définition

Signale la position d'index de base zéro de la dernière occurrence d'un caractère ou d'une chaîne Unicode spécifiés dans cette instance.Reports the zero-based index position of the last occurrence of a specified Unicode character or string within this instance. La méthode retourne -1 si le caractère ou la chaîne est introuvable dans cette instance.The method returns -1 if the character or string is not found in this instance.

Surcharges

LastIndexOf(String, Int32, StringComparison)

Signale l'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans l'objet String actuel.Reports the zero-based index of the last occurrence of a specified string within the current String object. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne.The search starts at a specified character position and proceeds backward toward the beginning of the string. Un paramètre spécifie le type de comparaison à effectuer pendant la recherche de la chaîne spécifiée.A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, Int32, Int32)

Signale la position d'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans cette instance.Reports the zero-based index position of the last occurrence of a specified string within this instance. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne pour un nombre spécifié de positions de caractères.The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

LastIndexOf(Char, Int32, Int32)

Signale la position d'index de base zéro de la dernière occurrence du caractère Unicode spécifié dans une sous-chaîne de cette instance.Reports the zero-based index position of the last occurrence of the specified Unicode character in a substring within this instance. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne pour un nombre spécifié de positions de caractères.The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

LastIndexOf(String, StringComparison)

Signale l'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans l'objet String actuel.Reports the zero-based index of the last occurrence of a specified string within the current String object. Un paramètre spécifie le type de recherche à utiliser pour la chaîne spécifiée.A parameter specifies the type of search to use for the specified string.

LastIndexOf(Char)

Signale la position d'index de base zéro de la dernière occurrence d'un caractère Unicode spécifié dans cette instance.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance.

LastIndexOf(Char, Int32)

Signale la position d'index de base zéro de la dernière occurrence d'un caractère Unicode spécifié dans cette instance.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne.The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(String)

Signale la position d'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans cette instance.Reports the zero-based index position of the last occurrence of a specified string within this instance.

LastIndexOf(String, Int32, Int32, StringComparison)

Signale la position d'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans cette instance.Reports the zero-based index position of the last occurrence of a specified string within this instance. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne pour le nombre spécifié de positions de caractères.The search starts at a specified character position and proceeds backward toward the beginning of the string for the specified number of character positions. Un paramètre spécifie le type de comparaison à effectuer pendant la recherche de la chaîne spécifiée.A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, Int32)

Signale la position d'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans cette instance.Reports the zero-based index position of the last occurrence of a specified string within this instance. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne.The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(String, Int32, StringComparison)

Signale l'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans l'objet String actuel.Reports the zero-based index of the last occurrence of a specified string within the current String object. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne.The search starts at a specified character position and proceeds backward toward the beginning of the string. Un paramètre spécifie le type de comparaison à effectuer pendant la recherche de la chaîne spécifiée.A parameter specifies the type of comparison to perform when searching for the specified string.

public:
 int LastIndexOf(System::String ^ value, int startIndex, StringComparison comparisonType);
public int LastIndexOf (string value, int startIndex, StringComparison comparisonType);
member this.LastIndexOf : string * int * StringComparison -> int
Public Function LastIndexOf (value As String, startIndex As Integer, comparisonType As StringComparison) As Integer

Paramètres

value
String

Chaîne à rechercher.The string to seek.

startIndex
Int32

Position de départ de la recherche.The search starting position. La recherche se poursuit à partir de startIndex vers le début de cette instance.The search proceeds from startIndex toward the beginning of this instance.

comparisonType
StringComparison

L'une des valeurs d'énumération qui spécifie les règles de la recherche.One of the enumeration values that specifies the rules for the search.

Retours

Position d'index de départ de base zéro du paramètre value si cette chaîne est trouvée, ou -1 si elle est introuvable ou si l'instance actuelle est égale à Empty.The zero-based starting index position of the value parameter if that string is found, or -1 if it is not found or if the current instance equals Empty. Si value est Empty, la valeur de retour est la plus petite de startIndex et la dernière position d'index dans cette instance.If value is Empty, the return value is the smaller of startIndex and the last index position in this instance.

Exceptions

value a la valeur null.value is null.

L’instance actuelle n’est pas égale à Empty, et startIndex est inférieur à zéro ou supérieur à la longueur de l’instance actuelle.The current instance does not equal Empty, and startIndex is less than zero or greater than the length of the current instance.

-ou--or-

L’instance actuelle est égale à Empty, et startIndex est inférieur à -1 ou supérieur à zéro.The current instance equals Empty, and startIndex is less than -1 or greater than zero.

comparisonType n’est pas une valeur de StringComparison valide.comparisonType is not a valid StringComparison value.

Exemples

L’exemple suivant montre trois surcharges de la méthode LastIndexOf qui recherchent la dernière occurrence d’une chaîne dans une autre chaîne en utilisant différentes valeurs de l’énumération StringComparison.The following example demonstrates three overloads of the LastIndexOf method that find the last occurrence of a string within another string using different values of the StringComparison enumeration.

// This code example demonstrates the 
// System.String.LastIndexOf(String, ..., StringComparison) methods.

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

class Sample 
{
    public static void Main() 
    {
    string intro = "Find the last occurrence of a character using different " + 
                   "values of StringComparison.";
    string resultFmt = "Comparison: {0,-28} Location: {1,3}";

// Define a string to search for.
// U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
    string CapitalAWithRing = "\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 cat = "A Cheshire c" + "\u0061\u030a" + "t";
    int loc = 0;
    StringComparison[] scValues = {
        StringComparison.CurrentCulture,
        StringComparison.CurrentCultureIgnoreCase,
        StringComparison.InvariantCulture,
        StringComparison.InvariantCultureIgnoreCase,
        StringComparison.Ordinal,
        StringComparison.OrdinalIgnoreCase };

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

// Display the current culture because culture affects the result. For example, 
// try this code example with the "sv-SE" (Swedish-Sweden) culture.

    Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
    Console.WriteLine("The current culture is \"{0}\" - {1}.", 
                       Thread.CurrentThread.CurrentCulture.Name,
                       Thread.CurrentThread.CurrentCulture.DisplayName);

// Display the string to search for and the string to search.
    Console.WriteLine("Search for the string \"{0}\" in the string \"{1}\"", 
                       CapitalAWithRing, cat);
    Console.WriteLine();

// Note that in each of the following searches, we look for 
// LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains 
// LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates 
// the string was not found.
// Search using different values of StringComparsion. Specify the start 
// index and count. 

    Console.WriteLine("Part 1: Start index and count are specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.LastIndexOf(CapitalAWithRing, cat.Length-1, cat.Length, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparsion. Specify the 
// start index. 
    Console.WriteLine("\nPart 2: Start index is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.LastIndexOf(CapitalAWithRing, cat.Length-1, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparsion. 
    Console.WriteLine("\nPart 3: Neither start index nor count is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.LastIndexOf(CapitalAWithRing, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }
    }
}

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

This code example produces the following results:

Find the last occurrence of a character using different values of StringComparison.
The current culture is "en-US" - English (United States).
Search for the string "Å" in the string "A Cheshire ca°t"

Part 1: Start index and count are specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 2: Start index is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 3: Neither start index nor count is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

*/
' This code example demonstrates the 
' System.String.LastIndexOf(String, ..., StringComparison) methods.

Imports System.Threading
Imports System.Globalization

Class Sample
    Public Shared Sub Main() 
        Dim intro As String = "Find the last occurrence of a character using different " & _
                              "values of StringComparison."
        Dim resultFmt As String = "Comparison: {0,-28} Location: {1,3}"
        
        ' Define a string to search for.
        ' U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
        Dim CapitalAWithRing As String = "Å"
        
        ' 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).
        Dim cat As String = "A Cheshire c" & "å" & "t"
        Dim loc As Integer = 0
        Dim scValues As StringComparison() =  { _
                        StringComparison.CurrentCulture, _
                        StringComparison.CurrentCultureIgnoreCase, _
                        StringComparison.InvariantCulture, _
                        StringComparison.InvariantCultureIgnoreCase, _
                        StringComparison.Ordinal, _
                        StringComparison.OrdinalIgnoreCase }
        Dim sc As StringComparison
        
        ' Clear the screen and display an introduction.
        Console.Clear()
        Console.WriteLine(intro)
        
        ' Display the current culture because culture affects the result. For example, 
        ' try this code example with the "sv-SE" (Swedish-Sweden) culture.
        Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
        Console.WriteLine("The current culture is ""{0}"" - {1}.", _
                           Thread.CurrentThread.CurrentCulture.Name, _
                           Thread.CurrentThread.CurrentCulture.DisplayName)
        
        ' Display the string to search for and the string to search.
        Console.WriteLine("Search for the string ""{0}"" in the string ""{1}""", _
                           CapitalAWithRing, cat)
        Console.WriteLine()
        
        ' Note that in each of the following searches, we look for 
        ' LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains 
        ' LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates 
        ' the string was not found.
        ' Search using different values of StringComparsion. Specify the start 
        ' index and count. 
        Console.WriteLine("Part 1: Start index and count are specified.")
        For Each sc In  scValues
            loc = cat.LastIndexOf(CapitalAWithRing, cat.Length - 1, cat.Length, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparsion. Specify the 
        ' start index. 
        Console.WriteLine(vbCrLf & "Part 2: Start index is specified.")
        For Each sc In  scValues
            loc = cat.LastIndexOf(CapitalAWithRing, cat.Length - 1, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparsion. 
        Console.WriteLine(vbCrLf & "Part 3: Neither start index nor count is specified.")
        For Each sc In  scValues
            loc = cat.LastIndexOf(CapitalAWithRing, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
    
    End Sub
End Class

'
'Note: This code example was executed on a console whose user interface 
'culture is "en-US" (English-United States).
'
'This code example produces the following results:
'
'Find the last occurrence of a character using different values of StringComparison.
'The current culture is "en-US" - English (United States).
'Search for the string "Å" in the string "A Cheshire ca°t"
'
'Part 1: Start index and count are specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'
'Part 2: Start index is specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'
'Part 3: Neither start index nor count is specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'

Remarques

La numérotation d’index commence à zéro.Index numbering starts from zero. Autrement dit, le premier caractère de la chaîne se trouve à l’index zéro et le dernier à Length-1.That is, the first character in the string is at index zero and the last is at Length - 1.

La recherche commence à la position du caractère startIndex et se poursuit vers l’arrière jusqu’à ce que value soit trouvé ou que la première position de caractère ait été examinée.The search begins at the startIndex character position and proceeds backward until either value is found or the first character position has been examined. Par exemple, si startIndex est Length-1, la méthode recherche le début de chaque caractère à partir du dernier caractère de la chaîne.For example, if startIndex is Length - 1, the method searches every character from the last character in the string to the beginning.

Le paramètre comparisonType spécifie de rechercher le paramètre value à l’aide de la culture actuelle ou indifférente, à l’aide d’une recherche respectant la casse ou non-respect de la casse, et en utilisant des règles de comparaison de mots ou ordinales.The comparisonType parameter specifies to search for the value parameter using the current or invariant culture, using a case-sensitive or case-insensitive search, and using word or ordinal comparison rules.

Notes pour les appelants

Les jeux de caractères incluent les caractères ignorables, à savoir les caractères qui ne sont pas considérés lors de l'exécution d'une comparaison linguistique ou dépendante de la culture.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. Dans une recherche dépendante de la culture (autrement dit, si comparisonType n'est pas Ordinal ou OrdinalIgnoreCase), si value contient un caractère ignorable, le résultat est équivalent à une recherche avec ce caractère supprimé.In a culture-sensitive search (that is, if comparisonType is not Ordinal or OrdinalIgnoreCase), if value contains an ignorable character, the result is equivalent to searching with that character removed. Si value se compose uniquement d’un ou de plusieurs caractères pouvant être ignorés, la méthode LastIndexOf(String, Int32, StringComparison) retourne toujours startIndex, qui est la position de caractère à laquelle la recherche commence.If value consists only of one or more ignorable characters, the LastIndexOf(String, Int32, StringComparison) method always returns startIndex, which is the character position at which the search begins.

Dans l’exemple suivant, la méthode LastIndexOf(String, Int32, StringComparison) est utilisée pour rechercher la position d’un trait d’union conditionnel (U + 00AD) suivi d’un « m », en commençant par le « m » final dans deux chaînes.In the following example, the LastIndexOf(String, Int32, StringComparison) method is used to find the position of a soft hyphen (U+00AD) followed by an "m", starting with the final "m" in two strings. Une seule des chaînes contient la sous-chaîne requise.Only one of the strings contains the required substring. Si l’exemple est exécuté sur le .NET Framework 4.NET Framework 4 ou version ultérieure, dans les deux cas, étant donné que le trait d’union conditionnel est un caractère pouvant être ignoré, la méthode retourne l’index de « m » dans la chaîne lorsqu’il effectue une comparaison dépendante de la culture.If the example is run on the .NET Framework 4.NET Framework 4 or later, in both cases, because the soft hyphen is an ignorable character, the method returns the index of "m" in the string when it performs a culture-sensitive comparison. Notez que, dans le cas de la première chaîne, qui inclut le trait d'union conditionnel suivi d'un « m », la méthode ne parvient pas à retourner l'index du trait d'union, mais retourne à la place celui de la lettre « m ».Note that in the case of the first string, which includes the soft hyphen followed by an "m", the method fails to return the index of the soft hyphen but instead returns the index of the "m". La méthode retourne l'index du trait d'union conditionnel dans la première chaîne uniquement lorsqu'elle effectue une comparaison ordinale.The method returns the index of the soft hyphen in the first string only when it performs an ordinal comparison.

[ ! code-CSharpSystem. String. LastIndexOf # 25] [ ! code-VBSystem. String. LastIndexOf # 25][!code-csharpSystem.String.LastIndexOf#25] [!code-vbSystem.String.LastIndexOf#25]

LastIndexOf(String, Int32, Int32)

Signale la position d'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans cette instance.Reports the zero-based index position of the last occurrence of a specified string within this instance. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne pour un nombre spécifié de positions de caractères.The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

public:
 int LastIndexOf(System::String ^ value, int startIndex, int count);
public int LastIndexOf (string value, int startIndex, int count);
member this.LastIndexOf : string * int * int -> int
Public Function LastIndexOf (value As String, startIndex As Integer, count As Integer) As Integer

Paramètres

value
String

Chaîne à rechercher.The string to seek.

startIndex
Int32

Position de départ de la recherche.The search starting position. La recherche se poursuit à partir de startIndex vers le début de cette instance.The search proceeds from startIndex toward the beginning of this instance.

count
Int32

Nombre de positions de caractère à examiner.The number of character positions to examine.

Retours

Position d'index de départ de base zéro de value si cette chaîne est trouvée, ou -1 si elle est introuvable ou si l'instance actuelle est égale à Empty.The zero-based starting index position of value if that string is found, or -1 if it is not found or if the current instance equals Empty. Si value est Empty, la valeur de retour est la plus petite de startIndex et la dernière position d'index dans cette instance.If value is Empty, the return value is the smaller of startIndex and the last index position in this instance.

Exceptions

value a la valeur null.value is null.

count est un nombre négatif.count is negative.

-ou--or-

L’instance actuelle n’est pas égale à Empty et startIndex est un nombre négatif.The current instance does not equal Empty, and startIndex is negative.

-ou--or-

L’instance actuelle n’est pas égale à Empty et startIndex est supérieur à la longueur de cette instance.The current instance does not equal Empty, and startIndex is greater than the length of this instance.

-ou--or-

L’instance actuelle n’est pas égale à Empty et startIndex - count + 1 spécifie une position qui ne figure pas dans cette instance.The current instance does not equal Empty, and startIndex - count+ 1 specifies a position that is not within this instance.

-ou--or-

L’instance actuelle est égale à Empty et start est inférieur à -1 ou supérieur à zéro.The current instance equals Empty and start is less than -1 or greater than zero.

-ou--or-

L’instance actuelle est égale à Empty et count est supérieur à 1.The current instance equals Empty and count is greater than 1.

Exemples

L’exemple suivant recherche l’index de toutes les occurrences d’une chaîne dans la sous-chaîne, en travaillant à partir de la fin de la sous-chaîne jusqu’au début de la sous-chaîne.The following example finds the index of all occurrences of a string in substring, working from the end of the substring to the start of the substring.

// Sample for String::LastIndexOf(String, Int32, Int32)
using namespace System;
int main()
{
   String^ br1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-";
   String^ br2 = "0123456789012345678901234567890123456789012345678901234567890123456";
   String^ str = "Now is the time for all good men to come to the aid of their party.";
   int start;
   int at;
   int count;
   int end;
   start = str->Length - 1;
   end = start / 2 - 1;
   Console::WriteLine( "All occurrences of 'he' from position {0} to {1}.", start, end );
   Console::WriteLine( "{1}{0}{2}{0}{3}{0}", Environment::NewLine, br1, br2, str );
   Console::Write( "The string 'he' occurs at position(s): " );
   count = 0;
   at = 0;
   while ( (start > -1) && (at > -1) )
   {
      count = start - end; //Count must be within the substring.
      at = str->LastIndexOf( "he", start, count );
      if ( at > -1 )
      {
         Console::Write( "{0} ", at );
         start = at - 1;
      }
   }

   Console::Write( "{0} {0} {0}", Environment::NewLine );
}

/*
This example produces the following results:
All occurrences of 'he' from position 66 to 32.
0----+----1----+----2----+----3----+----4----+----5----+----6----+-
0123456789012345678901234567890123456789012345678901234567890123456
Now is the time for all good men to come to the aid of their party.

The string 'he' occurs at position(s): 56 45
*/
// Sample for String.LastIndexOf(String, Int32, Int32)
using System;

class Sample {
    public static void Main() {

    string br1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-";
    string br2 = "0123456789012345678901234567890123456789012345678901234567890123456";
    string str = "Now is the time for all good men to come to the aid of their party.";
    int start;
    int at;
    int count;
    int end;

    start = str.Length-1;
    end = start/2 - 1;
    Console.WriteLine("All occurrences of 'he' from position {0} to {1}.", start, end);
    Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str);
    Console.Write("The string 'he' occurs at position(s): ");

    count = 0;
    at = 0;
    while((start > -1) && (at > -1))
        {
        count = start - end; //Count must be within the substring.
        at = str.LastIndexOf("he", start, count);
        if (at > -1)
            {
            Console.Write("{0} ", at);
            start = at - 1;
            }
        }
    Console.Write("{0}{0}{0}", Environment.NewLine);
    }
}
/*
This example produces the following results:
All occurrences of 'he' from position 66 to 32.
0----+----1----+----2----+----3----+----4----+----5----+----6----+-
0123456789012345678901234567890123456789012345678901234567890123456
Now is the time for all good men to come to the aid of their party.

The string 'he' occurs at position(s): 56 45
*/
' Sample for String.LastIndexOf(String, Int32, Int32)
 _

Class Sample
   
   Public Shared Sub Main()
      
      Dim br1 As String = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-"
      Dim br2 As String = "0123456789012345678901234567890123456789012345678901234567890123456"
      Dim str As String = "Now is the time for all good men to come to the aid of their party."
      Dim start As Integer
      Dim at As Integer
      Dim count As Integer
      Dim [end] As Integer

      start = str.Length - 1
      [end] = start / 2 - 1
      Console.WriteLine("All occurrences of 'he' from position {0} to {1}.", start, [end])
      Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str)
      Console.Write("The string 'he' occurs at position(s): ")
      
      count = 0
      at = 0
      While start > - 1 And at > - 1
         count = start - [end] 'Count must be within the substring.
         at = str.LastIndexOf("he", start, count)
         If at > - 1 Then
            Console.Write("{0} ", at)
            start = at - 1
         End If
      End While
      Console.Write("{0}{0}{0}", Environment.NewLine)
   End Sub
End Class
'
'This example produces the following results:
'All occurrences of 'he' from position 66 to 32.
'0----+----1----+----2----+----3----+----4----+----5----+----6----+-
'0123456789012345678901234567890123456789012345678901234567890123456
'Now is the time for all good men to come to the aid of their party.
'
'The string 'he' occurs at position(s): 56 45
'
'

Remarques

La numérotation d’index commence à zéro.Index numbering starts from zero. Autrement dit, le premier caractère de la chaîne se trouve à l’index zéro et le dernier à Length-1.That is, the first character in the string is at index zero and the last is at Length - 1.

La recherche commence à la position de caractère startIndex de cette instance et se poursuit vers le début jusqu’à ce que value soit trouvé ou que count positions de caractère aient été examinées.The search begins at the startIndex character position of this instance and proceeds backward toward the beginning until either value is found or count character positions have been examined. Par exemple, si startIndex est Length-1, la méthode recherche vers l’arrière count caractères à partir du dernier caractère de la chaîne.For example, if startIndex is Length - 1, the method searches backward count characters from the last character in the string.

Cette méthode effectue une recherche de mot (respectant la casse et dépendante de la culture) à l’aide de la culture actuelle.This method performs a word (case-sensitive and culture-sensitive) search using the current culture.

Les jeux de caractères incluent les caractères ignorables, à savoir les caractères qui ne sont pas considérés lors de l'exécution d'une comparaison linguistique ou dépendante de la culture.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. Dans une recherche dépendante de la culture, si value contient un caractère ignorable, le résultat est équivalent à la recherche avec ce caractère supprimé.In a culture-sensitive search, if value contains an ignorable character, the result is equivalent to searching with that character removed. Si value se compose uniquement d’un ou de plusieurs caractères pouvant être ignorés, la méthode LastIndexOf retourne toujours startIndex, qui est la position de caractère à laquelle la recherche commence.If value consists only of one or more ignorable characters, the LastIndexOf method always returns startIndex, which is the character position at which the search begins. Dans l’exemple suivant, la méthode LastIndexOf est utilisée pour rechercher la position d’un trait d’union conditionnel (U + 00AD) dans les deux caractères qui précèdent le « m » final de deux chaînes.In the following example, the LastIndexOf method is used to find the position of a soft hyphen (U+00AD) in the two characters that precede the final "m" of two strings. Une seule des chaînes contient la sous-chaîne requise.Only one of the strings contains the required substring. Si l’exemple est exécuté sur le .NET Framework 4.NET Framework 4 ou version ultérieure, dans les deux cas, étant donné que le trait d’union conditionnel est un caractère pouvant être ignoré, la méthode retourne l’index de « m » dans la chaîne lorsqu’il effectue une comparaison dépendante de la culture.If the example is run on the .NET Framework 4.NET Framework 4 or later, in both cases, because the soft hyphen is an ignorable character, the method returns the index of "m" in the string when it performs a culture-sensitive comparison. Notez que, dans le cas de la première chaîne, qui inclut le trait d'union conditionnel suivi d'un « m », la méthode ne parvient pas à retourner l'index du trait d'union, mais retourne à la place celui de la lettre « m ».Note that in the case of the first string, which includes the soft hyphen followed by an "m", the method fails to return the index of the soft hyphen but instead returns the index of the "m".

using System;

public class Example
{
   public static void Main()
   {
      int position = 0;
      string s1 = "ani\u00ADmal";
      string s2 = "animal";
      
      // Find the index of the soft hyphen.
      position = s1.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)
         Console.WriteLine(s1.LastIndexOf("\u00AD", position, position + 1));

      position = s2.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)   
         Console.WriteLine(s2.LastIndexOf("\u00AD", position, position + 1));
      
      // Find the index of the soft hyphen followed by "n".
      position = s1.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)
         Console.WriteLine(s1.LastIndexOf("\u00ADn", position, position + 1));

      position = s2.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)   
         Console.WriteLine(s2.LastIndexOf("\u00ADn", position, position + 1));
      
      // Find the index of the soft hyphen followed by "m".
      position = s1.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)
         Console.WriteLine(s1.LastIndexOf("\u00ADm", position, position + 1));

      position = s2.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)   
         Console.WriteLine(s2.LastIndexOf("\u00ADm", position, position + 1));
   }
}
// The example displays the following output:
//       'm' at position 4
//       4
//       'm' at position 3
//       3
//       'm' at position 4
//       1
//       'm' at position 3
//       1
//       'm' at position 4
//       4
//       'm' at position 3
//       3
Module Example
   Public Sub Main()
      Dim position As Integer
      Dim softHyphen As String = ChrW(&h00AD)
      
      Dim s1 As String = "ani" + softHyphen + "mal"
      Dim s2 As String = "animal"
      
      ' Find the index of the soft hyphen.
      position = s1.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s1.LastIndexOf(softHyphen, position, position + 1))
      End If
         
      position = s2.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s2.LastIndexOf(softHyphen, position, position + 1))
      End If
      
      ' Find the index of the soft hyphen followed by "n".
      position = s1.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s1.LastIndexOf(softHyphen + "n", position, position + 1))
      End If
         
      position = s2.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s2.LastIndexOf(softHyphen + "n", position, position + 1))
      End If
      
      ' Find the index of the soft hyphen followed by "m".
      position = s1.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s1.LastIndexOf(softHyphen + "m", position, position + 1))
      End If
      
      position = s2.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s2.LastIndexOf(softHyphen + "m", position, position + 1))
      End If
   End Sub
End Module
' The example displays the following output:
'       'm' at position 4
'       4
'       'm' at position 3
'       3
'       'm' at position 4
'       1
'       'm' at position 3
'       1
'       'm' at position 4
'       4
'       'm' at position 3
'       3

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 substituent des valeurs par défaut et appellent à la place des méthodes qui requièrent que des paramètres soient explicitement spécifiés.As explained in Best Practices for Using Strings, we recommend that you avoid calling string comparison methods that substitute default values and instead call methods that require parameters to be explicitly specified. Pour effectuer cette opération à l’aide des règles de comparaison de la culture actuelle, appelez la surcharge de méthode LastIndexOf(String, Int32, Int32, StringComparison) avec la valeur CurrentCulture pour son paramètre comparisonType.To perform this operation by using the comparison rules of the current culture, call the LastIndexOf(String, Int32, Int32, StringComparison) method overload with a value of CurrentCulture for its comparisonType parameter.

Voir aussi

LastIndexOf(Char, Int32, Int32)

Signale la position d'index de base zéro de la dernière occurrence du caractère Unicode spécifié dans une sous-chaîne de cette instance.Reports the zero-based index position of the last occurrence of the specified Unicode character in a substring within this instance. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne pour un nombre spécifié de positions de caractères.The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

public:
 int LastIndexOf(char value, int startIndex, int count);
public int LastIndexOf (char value, int startIndex, int count);
member this.LastIndexOf : char * int * int -> int
Public Function LastIndexOf (value As Char, startIndex As Integer, count As Integer) As Integer

Paramètres

value
Char

Caractère Unicode à rechercher.The Unicode character to seek.

startIndex
Int32

Position de départ de la recherche.The starting position of the search. La recherche se poursuit à partir de startIndex vers le début de cette instance.The search proceeds from startIndex toward the beginning of this instance.

count
Int32

Nombre de positions de caractère à examiner.The number of character positions to examine.

Retours

Position d'index de base zéro de value si ce caractère est trouvé, ou -1 s'il est introuvable ou si l'instance actuelle est égale à Empty.The zero-based index position of value if that character is found, or -1 if it is not found or if the current instance equals Empty.

Exceptions

L’instance actuelle n’est pas égale à Empty et startIndex est inférieur à zéro ou supérieur ou égal à la longueur de cette instance.The current instance does not equal Empty, and startIndex is less than zero or greater than or equal to the length of this instance.

-ou--or-

L’instance actuelle n’est pas égale à Empty et startIndex - count + 1 est inférieur à zéro.The current instance does not equal Empty, and startIndex - count + 1 is less than zero.

Exemples

L’exemple suivant recherche l’index de toutes les occurrences d’un caractère dans une sous-chaîne, en travaillant à partir de la fin de la sous-chaîne jusqu’au début de la sous-chaîne.The following example finds the index of all occurrences of a character in a substring, working from the end of the substring to the start of the substring.

// Sample for String::LastIndexOf(Char, Int32, Int32)
using namespace System;
int main()
{
   String^ br1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-";
   String^ br2 = "0123456789012345678901234567890123456789012345678901234567890123456";
   String^ str = "Now is the time for all good men to come to the aid of their party.";
   int start;
   int at;
   int count;
   int end;
   start = str->Length - 1;
   end = start / 2 - 1;
   Console::WriteLine( "All occurrences of 't' from position {0} to {1}.", start, end );
   Console::WriteLine( "\n{0}\n{1}\n{2}", br1, br2, str );
   Console::Write( "The letter 't' occurs at position(s): " );
   count = 0;
   at = 0;
   while ( (start > -1) && (at > -1) )
   {
      count = start - end; //Count must be within the substring.
      at = str->LastIndexOf( 't', start, count );
      if ( at > -1 )
      {
         Console::Write( " {0} ", at );
         start = at - 1;
      }
   }
}

/*
This example produces the following results:
All occurrences of 't' from position 66 to 32.
0----+----1----+----2----+----3----+----4----+----5----+----6----+-
0123456789012345678901234567890123456789012345678901234567890123456
Now is the time for all good men to come to the aid of their party.

The letter 't' occurs at position(s): 64 55 44 41 33


*/
// Sample for String.LastIndexOf(Char, Int32, Int32)
using System;

class Sample {
    public static void Main() {

    string br1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-";
    string br2 = "0123456789012345678901234567890123456789012345678901234567890123456";
    string str = "Now is the time for all good men to come to the aid of their party.";
    int start;
    int at;
    int count;
    int end;

    start = str.Length-1;
    end = start/2 - 1;
    Console.WriteLine("All occurrences of 't' from position {0} to {1}.", start, end);
    Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str);
    Console.Write("The letter 't' occurs at position(s): ");

    count = 0;
    at = 0;
    while((start > -1) && (at > -1))
        {
        count = start - end; //Count must be within the substring.
        at = str.LastIndexOf('t', start, count);
        if (at > -1)
            {
            Console.Write("{0} ", at);
            start = at - 1;
            }
        }
    Console.Write("{0}{0}{0}", Environment.NewLine);
    }
}
/*
This example produces the following results:
All occurrences of 't' from position 66 to 32.
0----+----1----+----2----+----3----+----4----+----5----+----6----+-
0123456789012345678901234567890123456789012345678901234567890123456
Now is the time for all good men to come to the aid of their party.

The letter 't' occurs at position(s): 64 55 44 41 33


*/
' Sample for String.LastIndexOf(Char, Int32, Int32)
 _

Class Sample
   
   Public Shared Sub Main()
      
      Dim br1 As String = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-"
      Dim br2 As String = "0123456789012345678901234567890123456789012345678901234567890123456"
      Dim str As String = "Now is the time for all good men to come to the aid of their party."
      Dim start As Integer
      Dim at As Integer
      Dim count As Integer
      Dim [end] As Integer

      start = str.Length - 1
      [end] = start / 2 - 1
      Console.WriteLine("All occurrences of 't' from position {0} to {1}.", start, [end])
      Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str)
      Console.Write("The letter 't' occurs at position(s): ")
      
      count = 0
      at = 0
      While start > - 1 And at > - 1
         count = start - [end] 'Count must be within the substring.
         at = str.LastIndexOf("t"c, start, count)
         If at > - 1 Then
            Console.Write("{0} ", at)
            start = at - 1
         End If
      End While
      Console.Write("{0}{0}{0}", Environment.NewLine)
   End Sub
End Class
'
'This example produces the following results:
'All occurrences of 't' from position 66 to 32.
'0----+----1----+----2----+----3----+----4----+----5----+----6----+-
'0123456789012345678901234567890123456789012345678901234567890123456
'Now is the time for all good men to come to the aid of their party.
'
'The letter 't' occurs at position(s): 64 55 44 41 33
'
'

Remarques

La numérotation d’index commence à zéro.Index numbering starts from zero. Autrement dit, le premier caractère de la chaîne se trouve à l’index zéro et le dernier à Length-1.That is, the first character in the string is at index zero and the last is at Length - 1.

Cette méthode commence la recherche à la position de caractère startIndex et se poursuit vers le début de cette instance jusqu’à ce que value soit trouvé ou que count positions de caractère aient été examinées.This method begins searching at the startIndex character position and proceeds backward toward the beginning of this instance until either value is found or count character positions have been examined. Par exemple, si startIndex est Length-1, la méthode recherche vers l’arrière count caractères à partir du dernier caractère de la chaîne.For example, if startIndex is Length - 1, the method searches backward count characters from the last character in the string. La recherche respecte la casse.The search is case-sensitive.

Cette méthode effectue une recherche ordinale (indépendante de la culture), où un caractère est considéré comme équivalent à un autre caractère uniquement si leurs valeurs scalaires Unicode sont identiques.This method performs an ordinal (culture-insensitive) search, where a character is considered equivalent to another character only if their Unicode scalar value are the same. Pour effectuer une recherche dépendante de la culture, utilisez la méthode CompareInfo.LastIndexOf, où une valeur scalaire Unicode représentant un caractère précomposé, telle que la ligature « Æ » (U + 00C6), peut être considérée comme équivalant à toute occurrence des composants du caractère dans l’ordre correct, par exemple « AE » (U + 0041, U + 0045), en fonction de la culture.To perform a culture-sensitive search, use the CompareInfo.LastIndexOf method, where a Unicode scalar value representing a precomposed character, such as the ligature "Æ" (U+00C6), might be considered equivalent to any occurrence of the character's components in the correct sequence, such as "AE" (U+0041, U+0045), depending on the culture.

Voir aussi

LastIndexOf(String, StringComparison)

Signale l'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans l'objet String actuel.Reports the zero-based index of the last occurrence of a specified string within the current String object. Un paramètre spécifie le type de recherche à utiliser pour la chaîne spécifiée.A parameter specifies the type of search to use for the specified string.

public:
 int LastIndexOf(System::String ^ value, StringComparison comparisonType);
public int LastIndexOf (string value, StringComparison comparisonType);
member this.LastIndexOf : string * StringComparison -> int
Public Function LastIndexOf (value As String, comparisonType As StringComparison) As Integer

Paramètres

value
String

Chaîne à rechercher.The string to seek.

comparisonType
StringComparison

L'une des valeurs d'énumération qui spécifie les règles de la recherche.One of the enumeration values that specifies the rules for the search.

Retours

Position de départ d'index de base zéro du paramètre value si cette chaîne est disponible ou -1 si elle est introuvable.The zero-based starting index position of the value parameter if that string is found, or -1 if it is not. Si value est Empty, la valeur de retour est la dernière position d'index dans cette instance.If value is Empty, the return value is the last index position in this instance.

Exceptions

value a la valeur null.value is null.

comparisonType n’est pas une valeur de StringComparison valide.comparisonType is not a valid StringComparison value.

Exemples

L’exemple suivant montre trois surcharges de la méthode LastIndexOf qui recherchent la dernière occurrence d’une chaîne dans une autre chaîne en utilisant différentes valeurs de l’énumération StringComparison.The following example demonstrates three overloads of the LastIndexOf method that find the last occurrence of a string within another string using different values of the StringComparison enumeration.

// This code example demonstrates the 
// System.String.LastIndexOf(String, ..., StringComparison) methods.

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

class Sample 
{
    public static void Main() 
    {
    string intro = "Find the last occurrence of a character using different " + 
                   "values of StringComparison.";
    string resultFmt = "Comparison: {0,-28} Location: {1,3}";

// Define a string to search for.
// U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
    string CapitalAWithRing = "\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 cat = "A Cheshire c" + "\u0061\u030a" + "t";
    int loc = 0;
    StringComparison[] scValues = {
        StringComparison.CurrentCulture,
        StringComparison.CurrentCultureIgnoreCase,
        StringComparison.InvariantCulture,
        StringComparison.InvariantCultureIgnoreCase,
        StringComparison.Ordinal,
        StringComparison.OrdinalIgnoreCase };

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

// Display the current culture because culture affects the result. For example, 
// try this code example with the "sv-SE" (Swedish-Sweden) culture.

    Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
    Console.WriteLine("The current culture is \"{0}\" - {1}.", 
                       Thread.CurrentThread.CurrentCulture.Name,
                       Thread.CurrentThread.CurrentCulture.DisplayName);

// Display the string to search for and the string to search.
    Console.WriteLine("Search for the string \"{0}\" in the string \"{1}\"", 
                       CapitalAWithRing, cat);
    Console.WriteLine();

// Note that in each of the following searches, we look for 
// LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains 
// LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates 
// the string was not found.
// Search using different values of StringComparsion. Specify the start 
// index and count. 

    Console.WriteLine("Part 1: Start index and count are specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.LastIndexOf(CapitalAWithRing, cat.Length-1, cat.Length, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparsion. Specify the 
// start index. 
    Console.WriteLine("\nPart 2: Start index is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.LastIndexOf(CapitalAWithRing, cat.Length-1, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparsion. 
    Console.WriteLine("\nPart 3: Neither start index nor count is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.LastIndexOf(CapitalAWithRing, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }
    }
}

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

This code example produces the following results:

Find the last occurrence of a character using different values of StringComparison.
The current culture is "en-US" - English (United States).
Search for the string "Å" in the string "A Cheshire ca°t"

Part 1: Start index and count are specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 2: Start index is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 3: Neither start index nor count is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

*/
' This code example demonstrates the 
' System.String.LastIndexOf(String, ..., StringComparison) methods.

Imports System.Threading
Imports System.Globalization

Class Sample
    Public Shared Sub Main() 
        Dim intro As String = "Find the last occurrence of a character using different " & _
                              "values of StringComparison."
        Dim resultFmt As String = "Comparison: {0,-28} Location: {1,3}"
        
        ' Define a string to search for.
        ' U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
        Dim CapitalAWithRing As String = "Å"
        
        ' 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).
        Dim cat As String = "A Cheshire c" & "å" & "t"
        Dim loc As Integer = 0
        Dim scValues As StringComparison() =  { _
                        StringComparison.CurrentCulture, _
                        StringComparison.CurrentCultureIgnoreCase, _
                        StringComparison.InvariantCulture, _
                        StringComparison.InvariantCultureIgnoreCase, _
                        StringComparison.Ordinal, _
                        StringComparison.OrdinalIgnoreCase }
        Dim sc As StringComparison
        
        ' Clear the screen and display an introduction.
        Console.Clear()
        Console.WriteLine(intro)
        
        ' Display the current culture because culture affects the result. For example, 
        ' try this code example with the "sv-SE" (Swedish-Sweden) culture.
        Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
        Console.WriteLine("The current culture is ""{0}"" - {1}.", _
                           Thread.CurrentThread.CurrentCulture.Name, _
                           Thread.CurrentThread.CurrentCulture.DisplayName)
        
        ' Display the string to search for and the string to search.
        Console.WriteLine("Search for the string ""{0}"" in the string ""{1}""", _
                           CapitalAWithRing, cat)
        Console.WriteLine()
        
        ' Note that in each of the following searches, we look for 
        ' LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains 
        ' LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates 
        ' the string was not found.
        ' Search using different values of StringComparsion. Specify the start 
        ' index and count. 
        Console.WriteLine("Part 1: Start index and count are specified.")
        For Each sc In  scValues
            loc = cat.LastIndexOf(CapitalAWithRing, cat.Length - 1, cat.Length, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparsion. Specify the 
        ' start index. 
        Console.WriteLine(vbCrLf & "Part 2: Start index is specified.")
        For Each sc In  scValues
            loc = cat.LastIndexOf(CapitalAWithRing, cat.Length - 1, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparsion. 
        Console.WriteLine(vbCrLf & "Part 3: Neither start index nor count is specified.")
        For Each sc In  scValues
            loc = cat.LastIndexOf(CapitalAWithRing, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
    
    End Sub
End Class

'
'Note: This code example was executed on a console whose user interface 
'culture is "en-US" (English-United States).
'
'This code example produces the following results:
'
'Find the last occurrence of a character using different values of StringComparison.
'The current culture is "en-US" - English (United States).
'Search for the string "Å" in the string "A Cheshire ca°t"
'
'Part 1: Start index and count are specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'
'Part 2: Start index is specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'
'Part 3: Neither start index nor count is specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'

Remarques

La numérotation d’index commence à zéro.Index numbering starts from zero. Autrement dit, le premier caractère de la chaîne se trouve à l’index zéro et le dernier à Length-1.That is, the first character in the string is at index zero and the last is at Length - 1.

Le paramètre comparisonType spécifie de rechercher le paramètre value à l’aide de la culture actuelle ou indifférente, à l’aide d’une recherche respectant la casse ou non-respect de la casse, et en utilisant des règles de comparaison de mots ou ordinales.The comparisonType parameter specifies to search for the value parameter using the current or invariant culture, using a case-sensitive or case-insensitive search, and using word or ordinal comparison rules.

La recherche commence à la position du dernier caractère de cette instance et se poursuit vers le début jusqu’à ce que value soit trouvé ou que la première position de caractère ait été examinée.The search begins at the last character position of this instance and proceeds backward toward the beginning until either value is found or the first character position has been examined.

Notes pour les appelants

Les jeux de caractères incluent les caractères ignorables, à savoir les caractères qui ne sont pas considérés lors de l'exécution d'une comparaison linguistique ou dépendante de la culture.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. Dans une recherche dépendante de la culture (autrement dit, si options n'est pas Ordinal ou OrdinalIgnoreCase), si value contient un caractère ignorable, le résultat est équivalent à une recherche avec ce caractère supprimé.In a culture-sensitive search (that is, if options is not Ordinal or OrdinalIgnoreCase), if value contains an ignorable character, the result is equivalent to searching with that character removed. Si value se compose uniquement d’un ou de plusieurs caractères pouvant être ignorés, la méthode LastIndexOf(String, StringComparison) retourne toujours Length-1, qui représente la dernière position d’index dans l’instance actuelle.If value consists only of one or more ignorable characters, the LastIndexOf(String, StringComparison) method always returns Length - 1, which represents the last index position in the current instance.

Dans l’exemple suivant, la méthode LastIndexOf(String, StringComparison) est utilisée pour rechercher trois sous-chaînes (un trait d’union conditionnel (U + 00AD), un trait d’union conditionnel suivi de « n » et un trait d’union conditionnel suivi de « m » dans deux chaînes.In the following example, the LastIndexOf(String, StringComparison) method is used to find three substrings (a soft hyphen (U+00AD), a soft hyphen followed by "n", and a soft hyphen followed by "m") in two strings. Une seule des chaînes contient un trait d'union conditionnel.Only one of the strings contains a soft hyphen. Si l’exemple est exécuté sur la .NET Framework 4.NET Framework 4 ou une version ultérieure, étant donné que le trait d’union conditionnel est un caractère pouvant être ignoré, une recherche dépendante de la culture retourne la même valeur que si le trait d’union conditionnel n’était pas inclus dans la chaîne de recherche.If the example is run on the .NET Framework 4.NET Framework 4 or later, because the soft hyphen is an ignorable character, a culture-sensitive search returns the same value that it would return if the soft hyphen were not included in the search string. Toutefois, une recherche ordinale trouve le trait d’union conditionnel dans une chaîne et signale qu’elle est absente de la deuxième chaîne.An ordinal search, however, successfully finds the soft hyphen in one string and reports that it is absent from the second string.

[ ! code-CSharpSystem. String. LastIndexOf # 26] [ ! code-VBSystem. String. LastIndexOf # 26][!code-csharpSystem.String.LastIndexOf#26] [!code-vbSystem.String.LastIndexOf#26]

LastIndexOf(Char)

Signale la position d'index de base zéro de la dernière occurrence d'un caractère Unicode spécifié dans cette instance.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance.

public:
 int LastIndexOf(char value);
public int LastIndexOf (char value);
member this.LastIndexOf : char -> int
Public Function LastIndexOf (value As Char) As Integer

Paramètres

value
Char

Caractère Unicode à rechercher.The Unicode character to seek.

Retours

Position d'index de base zéro de value si ce caractère est disponible ou -1 s'il est introuvable.The zero-based index position of value if that character is found, or -1 if it is not.

Exemples

L’exemple suivant définit une méthode ExtractFilename qui utilise la méthode LastIndexOf(Char) pour rechercher le dernier caractère de séparation de répertoire dans une chaîne et pour extraire le nom de fichier de la chaîne.The following example defines an ExtractFilename method that uses the LastIndexOf(Char) method to find the last directory separator character in a string and to extract the string's file name. Si le fichier existe, la méthode retourne le nom de fichier sans son chemin d’accès.If the file exists, the method returns the file name without its path.

using System;
using System.IO;

public class TestLastIndexOf
{
   public static void Main()
   {
      string filename;
      
      filename = ExtractFilename(@"C:\temp\");
      Console.WriteLine("{0}", String.IsNullOrEmpty(filename) ? "<none>" : filename);
      
      filename = ExtractFilename(@"C:\temp\delegate.txt"); 
      Console.WriteLine("{0}", String.IsNullOrEmpty(filename) ? "<none>" : filename);

      filename = ExtractFilename("delegate.txt");      
      Console.WriteLine("{0}", String.IsNullOrEmpty(filename) ? "<none>" : filename);
      
      filename = ExtractFilename(@"C:\temp\notafile.txt");
      Console.WriteLine("{0}", String.IsNullOrEmpty(filename) ? "<none>" : filename);
   }

   public static string ExtractFilename(string filepath)
   {
      // If path ends with a "\", it's a path only so return String.Empty.
      if (filepath.Trim().EndsWith(@"\"))
         return String.Empty;
      
      // Determine where last backslash is.
      int position = filepath.LastIndexOf('\\');
      // If there is no backslash, assume that this is a filename.
      if (position == -1)
      {
         // Determine whether file exists in the current directory.
         if (File.Exists(Environment.CurrentDirectory + Path.DirectorySeparatorChar + filepath)) 
            return filepath;
         else
            return String.Empty;
      }
      else
      {
         // Determine whether file exists using filepath.
         if (File.Exists(filepath))
            // Return filename without file path.
            return filepath.Substring(position + 1);
         else
            return String.Empty;
      }
   }
}
Imports System.IO

Public Module Test
   Public Sub Main()
      Dim filename As String 
      
      filename = ExtractFilename("C:\temp\")
      Console.WriteLine("{0}", IIf(String.IsNullOrEmpty(fileName), "<none>", filename))
      
      filename = ExtractFilename("C:\temp\delegate.txt") 
      Console.WriteLine("{0}", IIf(String.IsNullOrEmpty(fileName), "<none>", filename))

      filename = ExtractFilename("delegate.txt")      
      Console.WriteLine("{0}", IIf(String.IsNullOrEmpty(fileName), "<none>", filename))
      
      filename = ExtractFilename("C:\temp\notafile.txt")
      Console.WriteLine("{0}", IIf(String.IsNullOrEmpty(fileName), "<none>", filename))
   End Sub
   
   Public Function ExtractFilename(filepath As String) As String
      ' If path ends with a "\", it's a path only so return String.Empty.
      If filepath.Trim().EndsWith("\") Then Return String.Empty
      
      ' Determine where last backslash is.
      Dim position As Integer = filepath.LastIndexOf("\"c)
      ' If there is no backslash, assume that this is a filename.
      If position = -1 Then
         ' Determine whether file exists in the current directory.
         If File.Exists(Environment.CurrentDirectory + Path.DirectorySeparatorChar + filepath) Then
            Return filepath
         Else
            Return String.Empty
         End If
      Else
         ' Determine whether file exists using filepath.
         If File.Exists(filepath) Then
            ' Return filename without file path.
            Return filepath.Substring(position + 1)
         Else
            Return String.Empty
         End If                     
      End If
   End Function
End Module 
' The example displays the following output:
'        delegate.txt

Remarques

La numérotation d’index commence à zéro.Index numbering starts from zero. Autrement dit, le premier caractère de la chaîne se trouve à l’index zéro et le dernier à Length-1.That is, the first character in the string is at index zero and the last is at Length - 1.

Cette méthode commence la recherche à la position du dernier caractère de cette instance et se poursuit vers le début jusqu’à ce que value soit trouvé ou que la première position de caractère ait été examinée.This method begins searching at the last character position of this instance and proceeds backward toward the beginning until either value is found or the first character position has been examined. La recherche respecte la casse.The search is case-sensitive.

Cette méthode effectue une recherche ordinale (indépendante de la culture), où un caractère est considéré comme équivalent à un autre caractère uniquement si leurs valeurs scalaires Unicode sont identiques.This method performs an ordinal (culture-insensitive) search, where a character is considered equivalent to another character only if their Unicode scalar values are the same. Pour effectuer une recherche dépendante de la culture, utilisez la méthode CompareInfo.LastIndexOf, où une valeur scalaire Unicode représentant un caractère précomposé, telle que la ligature « Æ » (U + 00C6), peut être considérée comme équivalant à toute occurrence des composants du caractère dans l’ordre correct, par exemple « AE » (U + 0041, U + 0045), en fonction de la culture.To perform a culture-sensitive search, use the CompareInfo.LastIndexOf method, where a Unicode scalar value representing a precomposed character, such as the ligature "Æ" (U+00C6), might be considered equivalent to any occurrence of the character's components in the correct sequence, such as "AE" (U+0041, U+0045), depending on the culture.

Voir aussi

LastIndexOf(Char, Int32)

Signale la position d'index de base zéro de la dernière occurrence d'un caractère Unicode spécifié dans cette instance.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne.The search starts at a specified character position and proceeds backward toward the beginning of the string.

public:
 int LastIndexOf(char value, int startIndex);
public int LastIndexOf (char value, int startIndex);
member this.LastIndexOf : char * int -> int
Public Function LastIndexOf (value As Char, startIndex As Integer) As Integer

Paramètres

value
Char

Caractère Unicode à rechercher.The Unicode character to seek.

startIndex
Int32

Position de départ de la recherche.The starting position of the search. La recherche se poursuit à partir de startIndex vers le début de cette instance.The search proceeds from startIndex toward the beginning of this instance.

Retours

Position d'index de base zéro de value si ce caractère est trouvé, ou -1 s'il est introuvable ou si l'instance actuelle est égale à Empty.The zero-based index position of value if that character is found, or -1 if it is not found or if the current instance equals Empty.

Exceptions

L’instance actuelle n’est pas égale à Empty et startIndex est inférieur à zéro ou supérieur ou égal à la longueur de cette instance.The current instance does not equal Empty, and startIndex is less than zero or greater than or equal to the length of this instance.

Exemples

L’exemple suivant recherche l’index de toutes les occurrences d’un caractère dans une chaîne, en travaillant à partir de la fin de la chaîne jusqu’au début de la chaîne.The following example finds the index of all occurrences of a character in a string, working from the end of the string to the start of the string.

// Sample for String::LastIndexOf(Char, Int32)
using namespace System;
int main()
{
   String^ br1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-";
   String^ br2 = "0123456789012345678901234567890123456789012345678901234567890123456";
   String^ str = "Now is the time for all good men to come to the aid of their party.";
   int start;
   int at;
   start = str->Length - 1;
   Console::WriteLine( "All occurrences of 't' from position {0} to 0.", start );
   Console::WriteLine( "{0}\n{1}\n{2}\n", br1, br2, str );
   Console::Write( "The letter 't' occurs at position(s): " );
   at = 0;
   while ( (start > -1) && (at > -1) )
   {
      at = str->LastIndexOf( 't', start );
      if ( at > -1 )
      {
         Console::Write( " {0} ", at );
         start = at - 1;
      }
   }
}

/*
This example produces the following results:
All occurrences of 't' from position 66 to 0.
0----+----1----+----2----+----3----+----4----+----5----+----6----+-
0123456789012345678901234567890123456789012345678901234567890123456
Now is the time for all good men to come to the aid of their party.

The letter 't' occurs at position(s): 64 55 44 41 33 11 7
*/
// Sample for String.LastIndexOf(Char, Int32)
using System;

class Sample {
    public static void Main() {

    string br1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-";
    string br2 = "0123456789012345678901234567890123456789012345678901234567890123456";
    string str = "Now is the time for all good men to come to the aid of their party.";
    int start;
    int at;

    start = str.Length-1;
    Console.WriteLine("All occurrences of 't' from position {0} to 0.", start);
    Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str);
    Console.Write("The letter 't' occurs at position(s): ");

    at = 0;
    while((start > -1) && (at > -1))
        {
        at = str.LastIndexOf('t', start);
        if (at > -1)
            {
            Console.Write("{0} ", at);
            start = at - 1;
            }
        }
    Console.Write("{0}{0}{0}", Environment.NewLine);
    }
}
/*
This example produces the following results:
All occurrences of 't' from position 66 to 0.
0----+----1----+----2----+----3----+----4----+----5----+----6----+-
0123456789012345678901234567890123456789012345678901234567890123456
Now is the time for all good men to come to the aid of their party.

The letter 't' occurs at position(s): 64 55 44 41 33 11 7
*/
' Sample for String.LastIndexOf(Char, Int32)
Imports System 
 _

Class Sample
   
   Public Shared Sub Main()
      
      Dim br1 As String = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-"
      Dim br2 As String = "0123456789012345678901234567890123456789012345678901234567890123456"
      Dim str As String = "Now is the time for all good men to come to the aid of their party."
      Dim start As Integer
      Dim at As Integer
      
      start = str.Length - 1
      Console.WriteLine("All occurrences of 't' from position {0} to 0.", start)
      Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str)
      Console.Write("The letter 't' occurs at position(s): ")
      
      at = 0
      While start > - 1 And at > - 1
         at = str.LastIndexOf("t"c, start)
         If at > - 1 Then
            Console.Write("{0} ", at)
            start = at - 1
         End If
      End While
      Console.Write("{0}{0}{0}", Environment.NewLine)
   End Sub
End Class
'
'This example produces the following results:
'All occurrences of 't' from position 66 to 0.
'0----+----1----+----2----+----3----+----4----+----5----+----6----+-
'0123456789012345678901234567890123456789012345678901234567890123456
'Now is the time for all good men to come to the aid of their party.
'
'The letter 't' occurs at position(s): 64 55 44 41 33 11 7
'

Remarques

La numérotation d’index commence à zéro.Index numbering starts from zero. Autrement dit, le premier caractère de la chaîne se trouve à l’index zéro et le dernier à Length-1.That is, the first character in the string is at index zero and the last is at Length - 1. Cette méthode commence la recherche à la position de caractère startIndex de cette instance et se poursuit vers le début de l’instance actuelle jusqu’à ce que value soit trouvé ou que la première position de caractère ait été examinée.This method begins searching at the startIndex character position of this instance and proceeds backward toward the beginning of the current instance until either value is found or the first character position has been examined. Par exemple, si startIndex est Length-1, la méthode recherche le début de chaque caractère à partir du dernier caractère de la chaîne.For example, if startIndex is Length - 1, the method searches every character from the last character in the string to the beginning. La recherche respecte la casse.The search is case-sensitive.

Cette méthode effectue une recherche ordinale (indépendante de la culture), où un caractère est considéré comme équivalent à un autre caractère uniquement si leurs valeurs scalaires Unicode sont identiques.This method performs an ordinal (culture-insensitive) search, where a character is considered equivalent to another character only if their Unicode scalar values are the same. Pour effectuer une recherche dépendante de la culture, utilisez la méthode CompareInfo.LastIndexOf, où une valeur scalaire Unicode représentant un caractère précomposé, telle que la ligature « Æ » (U + 00C6), peut être considérée comme équivalant à toute occurrence des composants du caractère dans l’ordre correct, par exemple « AE » (U + 0041, U + 0045), en fonction de la culture.To perform a culture-sensitive search, use the CompareInfo.LastIndexOf method, where a Unicode scalar value representing a precomposed character, such as the ligature "Æ" (U+00C6), might be considered equivalent to any occurrence of the character's components in the correct sequence, such as "AE" (U+0041, U+0045), depending on the culture.

Voir aussi

LastIndexOf(String)

Signale la position d'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans cette instance.Reports the zero-based index position of the last occurrence of a specified string within this instance.

public:
 int LastIndexOf(System::String ^ value);
public int LastIndexOf (string value);
member this.LastIndexOf : string -> int
Public Function LastIndexOf (value As String) As Integer

Paramètres

value
String

Chaîne à rechercher.The string to seek.

Retours

Position d'index de départ de base zéro de value si cette chaîne est disponible ou -1 si elle est introuvable.The zero-based starting index position of value if that string is found, or -1 if it is not. Si value est Empty, la valeur de retour est la dernière position d'index dans cette instance.If value is Empty, the return value is the last index position in this instance.

Exceptions

value a la valeur null.value is null.

Exemples

L’exemple suivant supprime les balises HTML ouvrantes et fermantes d’une chaîne si les balises commencent et terminent la chaîne.The following example removes opening and closing HTML tags from a string if the tags begin and end the string. Si une chaîne se termine par un crochet fermant (« > »), l’exemple utilise la méthode LastIndexOf pour localiser le début de la balise de fin.If a string ends with a closing bracket character (">"), the example uses the LastIndexOf method to locate the start of the end tag.

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

      // Strip HTML start and end tags from each string if they are present.
      foreach (string s in strSource)
      {
         Console.WriteLine("Before: " + s);
         string item = s;
         // Use EndsWith to find a tag at the end of the line.
         if (item.Trim().EndsWith(">")) 
         {
            // Locate the opening tag.
            int endTagStartPosition = item.LastIndexOf("</");
            // Remove the identified section, if it is valid.
            if (endTagStartPosition >= 0 )
               item = item.Substring(0, endTagStartPosition);

            // Use StartsWith to find the opening tag.
            if (item.Trim().StartsWith("<"))
            {
               // Locate the end of opening tab.
               int openTagEndPosition = item.IndexOf(">");
               // Remove the identified section, if it is valid.
               if (openTagEndPosition >= 0)
                  item = item.Substring(openTagEndPosition + 1);
            }      
         }
         // Display the trimmed string.
         Console.WriteLine("After: " + item);
         Console.WriteLine();
      }                   
   }
}
// The example displays the following output:
//    Before: <b>This is bold text</b>
//    After: This is bold text
//    
//    Before: <H1>This is large Text</H1>
//    After: This is large Text
//    
//    Before: <b><i><font color=green>This has multiple tags</font></i></b>
//    After: <i><font color=green>This has multiple tags</font></i>
//    
//    Before: <b>This has <i>embedded</i> tags.</b>
//    After: This has <i>embedded</i> tags.
//    
//    Before: This line ends with a greater than symbol and should not be modified>
//    After: This line ends with a greater than symbol and should not be modified>
Module Example
   Public Sub Main()
      Dim strSource As String() = { "<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 ends with a greater than symbol and should not be modified>" }

      ' Strip HTML start and end tags from each string if they are present.
      For Each s As String In strSource
         Console.WriteLine("Before: " + s)
         ' Use EndsWith to find a tag at the end of the line.
         If s.Trim().EndsWith(">") Then 
            ' Locate the opening tag.
            Dim endTagStartPosition As Integer = s.LastIndexOf("</")
            ' Remove the identified section if it is valid.
            If endTagStartPosition >= 0 Then
               s = s.Substring(0, endTagStartPosition)
            End If
            
            ' Use StartsWith to find the opening tag.
            If s.Trim().StartsWith("<") Then
               ' Locate the end of opening tab.
               Dim openTagEndPosition As Integer = s.IndexOf(">")
               ' Remove the identified section if it is valid.
               If openTagEndPosition >= 0 Then
                  s = s.Substring(openTagEndPosition + 1)
               End If   
            End If      
         End If
         ' Display the trimmed string.
         Console.WriteLine("After: " + s)
         Console.WriteLine()
      Next                   
   End Sub
End Module
' The example displays the following output:
'    Before: <b>This is bold text</b>
'    After: This is bold text
'    
'    Before: <H1>This is large Text</H1>
'    After: This is large Text
'    
'    Before: <b><i><font color=green>This has multiple tags</font></i></b>
'    After: <i><font color=green>This has multiple tags</font></i>
'    
'    Before: <b>This has <i>embedded</i> tags.</b>
'    After: This has <i>embedded</i> tags.
'    
'    Before: This line ends with a greater than symbol and should not be modified>
'    After: This line ends with a greater than symbol and should not be modified>

Remarques

La numérotation d’index commence à zéro.Index numbering starts from zero. Autrement dit, le premier caractère de la chaîne se trouve à l’index zéro et le dernier à Length-1.That is, the first character in the string is at index zero and the last is at Length - 1.

La recherche commence à la position du dernier caractère de cette instance et se poursuit vers le début jusqu’à ce que value soit trouvé ou que la première position de caractère ait été examinée.The search begins at the last character position of this instance and proceeds backward toward the beginning until either value is found or the first character position has been examined.

Cette méthode effectue une recherche de mot (respectant la casse et dépendante de la culture) à l’aide de la culture actuelle.This method performs a word (case-sensitive and culture-sensitive) search using the current culture.

Les jeux de caractères incluent les caractères ignorables, à savoir les caractères qui ne sont pas considérés lors de l'exécution d'une comparaison linguistique ou dépendante de la culture.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. Dans une recherche dépendante de la culture, si value contient un caractère ignorable, le résultat est équivalent à la recherche avec ce caractère supprimé.In a culture-sensitive search, if value contains an ignorable character, the result is equivalent to searching with that character removed. Si value se compose uniquement d’un ou de plusieurs caractères pouvant être ignorés, la méthode LastIndexOf(String) retourne toujours String.Length-1, qui représente la dernière position d’index dans l’instance actuelle.If value consists only of one or more ignorable characters, the LastIndexOf(String) method always returns String.Length - 1, which represents the last index position in the current instance. Dans l’exemple suivant, la méthode LastIndexOf(String) est utilisée pour rechercher trois sous-chaînes (un trait d’union conditionnel (U + 00AD), un trait d’union conditionnel suivi de « n » et un trait d’union conditionnel suivi de « m » dans deux chaînes.In the following example, the LastIndexOf(String) method is used to find three substrings (a soft hyphen (U+00AD), a soft hyphen followed by "n", and a soft hyphen followed by "m") in two strings. Une seule des chaînes contient un trait d'union conditionnel.Only one of the strings contains a soft hyphen. Si l’exemple est exécuté sur le .NET Framework 4.NET Framework 4 ou version ultérieure, dans chaque cas, étant donné que le trait d’union conditionnel est un caractère pouvant être ignoré, le résultat est le même que si le trait d’union conditionnel n’avait pas été inclus dans value.If the example is run on the .NET Framework 4.NET Framework 4 or later, in each case, because the soft hyphen is an ignorable character, the result is the same as if the soft hyphen had not been included in value. Lors de la recherche d’un trait d’union conditionnel uniquement, la méthode retourne 6 et 5.When searching for a soft hyphen only, the method returns 6 and 5. Ces valeurs correspondent à l’index du dernier caractère des deux chaînes.These values correspond to the index of the last character in the two strings.

using System;

public class Example
{
   public static void Main()
   {
      string s1 = "ani\u00ADmal";
      string s2 = "animal";
      
      // Find the index of the last soft hyphen.
      Console.WriteLine(s1.LastIndexOf("\u00AD"));
      Console.WriteLine(s2.LastIndexOf("\u00AD"));
      
      // Find the index of the last soft hyphen followed by "n".
      Console.WriteLine(s1.LastIndexOf("\u00ADn"));
      Console.WriteLine(s2.LastIndexOf("\u00ADn"));
      
      // Find the index of the last soft hyphen followed by "m".
      Console.WriteLine(s1.LastIndexOf("\u00ADm"));
      Console.WriteLine(s2.LastIndexOf("\u00ADm"));
   }
}
// The example displays the following output:
//       6
//       5
//       1
//       1
//       4
//       3
Module Example
   Public Sub Main()
      Dim softHyphen As String = ChrW(&h00AD)
      Dim s1 As String = "ani" + softHyphen + "mal"
      Dim s2 As String = "animal"
      
      ' Find the index of the last soft hyphen.
      Console.WriteLine(s1.LastIndexOf(softHyphen))
      Console.WriteLine(s2.LastIndexOf(softHyphen))
      
      ' Find the index of the last soft hyphen followed by "n".
      Console.WriteLine(s1.LastIndexOf(softHyphen + "n"))
      Console.WriteLine(s2.LastIndexOf(softHyphen + "n"))
      
      ' Find the index of the last soft hyphen followed by "m".
      Console.WriteLine(s1.LastIndexOf(softHyphen + "m"))
      Console.WriteLine(s2.LastIndexOf(softHyphen + "m"))
   End Sub
End Module
' The example displays the following output:
'       6
'       5
'       1
'       1
'       4
'       3

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 substituent des valeurs par défaut et appellent à la place des méthodes qui requièrent que des paramètres soient explicitement spécifiés.As explained in Best Practices for Using Strings, we recommend that you avoid calling string comparison methods that substitute default values and instead call methods that require parameters to be explicitly specified. Pour rechercher le dernier index d’une sous-chaîne dans une instance de chaîne à l’aide des règles de comparaison de la culture actuelle, appelez la surcharge de méthode LastIndexOf(String, StringComparison) avec la valeur CurrentCulture pour son paramètre comparisonType.To find the last index of a substring within a string instance by using the comparison rules of the current culture, call the LastIndexOf(String, StringComparison) method overload with a value of CurrentCulture for its comparisonType parameter.

Voir aussi

LastIndexOf(String, Int32, Int32, StringComparison)

Signale la position d'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans cette instance.Reports the zero-based index position of the last occurrence of a specified string within this instance. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne pour le nombre spécifié de positions de caractères.The search starts at a specified character position and proceeds backward toward the beginning of the string for the specified number of character positions. Un paramètre spécifie le type de comparaison à effectuer pendant la recherche de la chaîne spécifiée.A parameter specifies the type of comparison to perform when searching for the specified string.

public:
 int LastIndexOf(System::String ^ value, int startIndex, int count, StringComparison comparisonType);
public int LastIndexOf (string value, int startIndex, int count, StringComparison comparisonType);
member this.LastIndexOf : string * int * int * StringComparison -> int
Public Function LastIndexOf (value As String, startIndex As Integer, count As Integer, comparisonType As StringComparison) As Integer

Paramètres

value
String

Chaîne à rechercher.The string to seek.

startIndex
Int32

Position de départ de la recherche.The search starting position. La recherche se poursuit à partir de startIndex vers le début de cette instance.The search proceeds from startIndex toward the beginning of this instance.

count
Int32

Nombre de positions de caractère à examiner.The number of character positions to examine.

comparisonType
StringComparison

L'une des valeurs d'énumération qui spécifie les règles de la recherche.One of the enumeration values that specifies the rules for the search.

Retours

Position d'index de départ de base zéro du paramètre value si cette chaîne est trouvée, ou -1 si elle est introuvable ou si l'instance actuelle est égale à Empty.The zero-based starting index position of the value parameter if that string is found, or -1 if it is not found or if the current instance equals Empty. Si value est Empty, la valeur de retour est la plus petite de startIndex et la dernière position d'index dans cette instance.If value is Empty, the return value is the smaller of startIndex and the last index position in this instance.

Exceptions

value a la valeur null.value is null.

count est un nombre négatif.count is negative.

-ou--or-

L’instance actuelle n’est pas égale à Empty et startIndex est un nombre négatif.The current instance does not equal Empty, and startIndex is negative.

-ou--or-

L’instance actuelle n’est pas égale à Empty et startIndex est supérieur à la longueur de cette instance.The current instance does not equal Empty, and startIndex is greater than the length of this instance.

-ou--or-

L’instance actuelle n’est pas égale à Empty et startIndex - count + 1 spécifie une position qui ne figure pas dans cette instance.The current instance does not equal Empty, and startIndex + 1 - count specifies a position that is not within this instance.

-ou--or-

L’instance actuelle est égale à Empty et start est inférieur à -1 ou supérieur à zéro.The current instance equals Empty and start is less than -1 or greater than zero.

-ou--or-

L’instance actuelle est égale à Empty et count est supérieur à 1.The current instance equals Empty and count is greater than 1.

comparisonType n’est pas une valeur de StringComparison valide.comparisonType is not a valid StringComparison value.

Exemples

L’exemple suivant montre trois surcharges de la méthode LastIndexOf qui recherchent la dernière occurrence d’une chaîne dans une autre chaîne en utilisant différentes valeurs de l’énumération StringComparison.The following example demonstrates three overloads of the LastIndexOf method that find the last occurrence of a string within another string using different values of the StringComparison enumeration.

// This code example demonstrates the 
// System.String.LastIndexOf(String, ..., StringComparison) methods.

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

class Sample 
{
    public static void Main() 
    {
    string intro = "Find the last occurrence of a character using different " + 
                   "values of StringComparison.";
    string resultFmt = "Comparison: {0,-28} Location: {1,3}";

// Define a string to search for.
// U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
    string CapitalAWithRing = "\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 cat = "A Cheshire c" + "\u0061\u030a" + "t";
    int loc = 0;
    StringComparison[] scValues = {
        StringComparison.CurrentCulture,
        StringComparison.CurrentCultureIgnoreCase,
        StringComparison.InvariantCulture,
        StringComparison.InvariantCultureIgnoreCase,
        StringComparison.Ordinal,
        StringComparison.OrdinalIgnoreCase };

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

// Display the current culture because culture affects the result. For example, 
// try this code example with the "sv-SE" (Swedish-Sweden) culture.

    Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
    Console.WriteLine("The current culture is \"{0}\" - {1}.", 
                       Thread.CurrentThread.CurrentCulture.Name,
                       Thread.CurrentThread.CurrentCulture.DisplayName);

// Display the string to search for and the string to search.
    Console.WriteLine("Search for the string \"{0}\" in the string \"{1}\"", 
                       CapitalAWithRing, cat);
    Console.WriteLine();

// Note that in each of the following searches, we look for 
// LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains 
// LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates 
// the string was not found.
// Search using different values of StringComparsion. Specify the start 
// index and count. 

    Console.WriteLine("Part 1: Start index and count are specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.LastIndexOf(CapitalAWithRing, cat.Length-1, cat.Length, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparsion. Specify the 
// start index. 
    Console.WriteLine("\nPart 2: Start index is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.LastIndexOf(CapitalAWithRing, cat.Length-1, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }

// Search using different values of StringComparsion. 
    Console.WriteLine("\nPart 3: Neither start index nor count is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.LastIndexOf(CapitalAWithRing, sc);
        Console.WriteLine(resultFmt, sc, loc);
        }
    }
}

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

This code example produces the following results:

Find the last occurrence of a character using different values of StringComparison.
The current culture is "en-US" - English (United States).
Search for the string "Å" in the string "A Cheshire ca°t"

Part 1: Start index and count are specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 2: Start index is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

Part 3: Neither start index nor count is specified.
Comparison: CurrentCulture               Location:  -1
Comparison: CurrentCultureIgnoreCase     Location:  12
Comparison: InvariantCulture             Location:  -1
Comparison: InvariantCultureIgnoreCase   Location:  12
Comparison: Ordinal                      Location:  -1
Comparison: OrdinalIgnoreCase            Location:  -1

*/
' This code example demonstrates the 
' System.String.LastIndexOf(String, ..., StringComparison) methods.

Imports System.Threading
Imports System.Globalization

Class Sample
    Public Shared Sub Main() 
        Dim intro As String = "Find the last occurrence of a character using different " & _
                              "values of StringComparison."
        Dim resultFmt As String = "Comparison: {0,-28} Location: {1,3}"
        
        ' Define a string to search for.
        ' U+00c5 = LATIN CAPITAL LETTER A WITH RING ABOVE
        Dim CapitalAWithRing As String = "Å"
        
        ' 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).
        Dim cat As String = "A Cheshire c" & "å" & "t"
        Dim loc As Integer = 0
        Dim scValues As StringComparison() =  { _
                        StringComparison.CurrentCulture, _
                        StringComparison.CurrentCultureIgnoreCase, _
                        StringComparison.InvariantCulture, _
                        StringComparison.InvariantCultureIgnoreCase, _
                        StringComparison.Ordinal, _
                        StringComparison.OrdinalIgnoreCase }
        Dim sc As StringComparison
        
        ' Clear the screen and display an introduction.
        Console.Clear()
        Console.WriteLine(intro)
        
        ' Display the current culture because culture affects the result. For example, 
        ' try this code example with the "sv-SE" (Swedish-Sweden) culture.
        Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
        Console.WriteLine("The current culture is ""{0}"" - {1}.", _
                           Thread.CurrentThread.CurrentCulture.Name, _
                           Thread.CurrentThread.CurrentCulture.DisplayName)
        
        ' Display the string to search for and the string to search.
        Console.WriteLine("Search for the string ""{0}"" in the string ""{1}""", _
                           CapitalAWithRing, cat)
        Console.WriteLine()
        
        ' Note that in each of the following searches, we look for 
        ' LATIN CAPITAL LETTER A WITH RING ABOVE in a string that contains 
        ' LATIN SMALL LETTER A WITH RING ABOVE. A result value of -1 indicates 
        ' the string was not found.
        ' Search using different values of StringComparsion. Specify the start 
        ' index and count. 
        Console.WriteLine("Part 1: Start index and count are specified.")
        For Each sc In  scValues
            loc = cat.LastIndexOf(CapitalAWithRing, cat.Length - 1, cat.Length, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparsion. Specify the 
        ' start index. 
        Console.WriteLine(vbCrLf & "Part 2: Start index is specified.")
        For Each sc In  scValues
            loc = cat.LastIndexOf(CapitalAWithRing, cat.Length - 1, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
        
        ' Search using different values of StringComparsion. 
        Console.WriteLine(vbCrLf & "Part 3: Neither start index nor count is specified.")
        For Each sc In  scValues
            loc = cat.LastIndexOf(CapitalAWithRing, sc)
            Console.WriteLine(resultFmt, sc, loc)
        Next sc
    
    End Sub
End Class

'
'Note: This code example was executed on a console whose user interface 
'culture is "en-US" (English-United States).
'
'This code example produces the following results:
'
'Find the last occurrence of a character using different values of StringComparison.
'The current culture is "en-US" - English (United States).
'Search for the string "Å" in the string "A Cheshire ca°t"
'
'Part 1: Start index and count are specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'
'Part 2: Start index is specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'
'Part 3: Neither start index nor count is specified.
'Comparison: CurrentCulture               Location:  -1
'Comparison: CurrentCultureIgnoreCase     Location:  12
'Comparison: InvariantCulture             Location:  -1
'Comparison: InvariantCultureIgnoreCase   Location:  12
'Comparison: Ordinal                      Location:  -1
'Comparison: OrdinalIgnoreCase            Location:  -1
'

Remarques

La numérotation d’index commence à zéro.Index numbering starts from zero. Autrement dit, le premier caractère de la chaîne se trouve à l’index zéro et le dernier à Length-1.That is, the first character in the string is at index zero and the last is at Length - 1.

La recherche commence à la position du caractère startIndex et se poursuit vers l’arrière jusqu’à ce que value soit trouvé ou que count positions de caractère aient été examinées.The search begins at the startIndex character position and proceeds backward until either value is found or count character positions have been examined. Par exemple, si startIndex est Length-1, la méthode recherche vers l’arrière count caractères à partir du dernier caractère de la chaîne.For example, if startIndex is Length - 1, the method searches backward count characters from the last character in the string.

Le paramètre comparisonType spécifie de rechercher le paramètre value à l’aide de la culture actuelle ou indifférente, à l’aide d’une recherche respectant la casse ou non-respect de la casse, et en utilisant des règles de comparaison de mots ou ordinales.The comparisonType parameter specifies to search for the value parameter using the current or invariant culture, using a case-sensitive or case-insensitive search, and using word or ordinal comparison rules.

Notes pour les appelants

Les jeux de caractères incluent les caractères ignorables, à savoir les caractères qui ne sont pas considérés lors de l'exécution d'une comparaison linguistique ou dépendante de la culture.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. Dans une recherche dépendante de la culture (autrement dit, si comparisonType n'est pas Ordinal ou OrdinalIgnoreCase), si value contient un caractère ignorable, le résultat est équivalent à une recherche avec ce caractère supprimé.In a culture-sensitive search (that is, if comparisonType is not Ordinal or OrdinalIgnoreCase), if value contains an ignorable character, the result is equivalent to searching with that character removed. Si value se compose uniquement d’un ou de plusieurs caractères pouvant être ignorés, la méthode LastIndexOf(String, Int32, Int32, StringComparison) retourne toujours startIndex, qui est la position de caractère à laquelle la recherche commence.If value consists only of one or more ignorable characters, the LastIndexOf(String, Int32, Int32, StringComparison) method always returns startIndex, which is the character position at which the search begins.

Dans l’exemple suivant, la méthode LastIndexOf(String, Int32, Int32, StringComparison) est utilisée pour rechercher la position d’un trait d’union conditionnel (U + 00AD) suivi d’un « m » dans tout sauf la position du premier caractère avant le « m » final dans deux chaînes.In the following example, the LastIndexOf(String, Int32, Int32, StringComparison) method is used to find the position of a soft hyphen (U+00AD) followed by an "m" in all but the first character position before the final "m" in two strings. Une seule des chaînes contient la sous-chaîne requise.Only one of the strings contains the required substring. Si l’exemple est exécuté sur le .NET Framework 4.NET Framework 4 ou version ultérieure, dans les deux cas, étant donné que le trait d’union conditionnel est un caractère pouvant être ignoré, la méthode retourne l’index de « m » dans la chaîne lorsqu’il effectue une comparaison dépendante de la culture.If the example is run on the .NET Framework 4.NET Framework 4 or later, in both cases, because the soft hyphen is an ignorable character, the method returns the index of "m" in the string when it performs a culture-sensitive comparison. Toutefois, lorsqu’il effectue une comparaison ordinale, il trouve uniquement la sous-chaîne dans la première chaîne.When it performs an ordinal comparison, however, it finds the substring only in the first string. Notez que, dans le cas de la première chaîne, qui comprend le trait d’union conditionnel suivi d’un « m », la méthode ne retourne pas l’index du trait d’union conditionnel mais retourne à la place l’index du « m » lorsqu’il effectue une comparaison dépendante de la culture.Note that in the case of the first string, which includes the soft hyphen followed by an "m", the method fails to return the index of the soft hyphen but instead returns the index of the "m" when it performs a culture-sensitive comparison. La méthode retourne l'index du trait d'union conditionnel dans la première chaîne uniquement lorsqu'elle effectue une comparaison ordinale.The method returns the index of the soft hyphen in the first string only when it performs an ordinal comparison.

[ ! code-CSharpSystem. String. LastIndexOf # 24] [ ! code-VBSystem. String. LastIndexOf # 24][!code-csharpSystem.String.LastIndexOf#24] [!code-vbSystem.String.LastIndexOf#24]

LastIndexOf(String, Int32)

Signale la position d'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans cette instance.Reports the zero-based index position of the last occurrence of a specified string within this instance. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne.The search starts at a specified character position and proceeds backward toward the beginning of the string.

public:
 int LastIndexOf(System::String ^ value, int startIndex);
public int LastIndexOf (string value, int startIndex);
member this.LastIndexOf : string * int -> int
Public Function LastIndexOf (value As String, startIndex As Integer) As Integer

Paramètres

value
String

Chaîne à rechercher.The string to seek.

startIndex
Int32

Position de départ de la recherche.The search starting position. La recherche se poursuit à partir de startIndex vers le début de cette instance.The search proceeds from startIndex toward the beginning of this instance.

Retours

Position d'index de départ de base zéro de value si cette chaîne est trouvée, ou -1 si elle est introuvable ou si l'instance actuelle est égale à Empty.The zero-based starting index position of value if that string is found, or -1 if it is not found or if the current instance equals Empty. Si value est Empty, la valeur de retour est la plus petite de startIndex et la dernière position d'index dans cette instance.If value is Empty, the return value is the smaller of startIndex and the last index position in this instance.

Exceptions

value a la valeur null.value is null.

L’instance actuelle n’est pas égale à Empty, et startIndex est inférieur à zéro ou supérieur à la longueur de l’instance actuelle.The current instance does not equal Empty, and startIndex is less than zero or greater than the length of the current instance.

-ou--or-

L’instance actuelle est égale à Empty, et startIndex est inférieur à -1 ou supérieur à zéro.The current instance equals Empty, and startIndex is less than -1 or greater than zero.

Exemples

L’exemple suivant recherche l’index de toutes les occurrences d’une chaîne dans la chaîne cible, en travaillant à partir de la fin de la chaîne cible jusqu’au début de la chaîne cible.The following example finds the index of all occurrences of a string in target string, working from the end of the target string to the start of the target string.

// Sample for String::LastIndexOf(String, Int32)
using namespace System;
int main()
{
   String^ br1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-";
   String^ br2 = "0123456789012345678901234567890123456789012345678901234567890123456";
   String^ str = "Now is the time for all good men to come to the aid of their party.";
   int start;
   int at;
   start = str->Length - 1;
   Console::WriteLine( "All occurrences of 'he' from position {0} to 0.", start );
   Console::WriteLine( "{0}\n{1}\n{2}\n", br1, br2, str );
   Console::Write( "The string 'he' occurs at position(s): " );
   at = 0;
   while ( (start > -1) && (at > -1) )
   {
      at = str->LastIndexOf( "he", start );
      if ( at > -1 )
      {
         Console::Write( " {0} ", at );
         start = at - 1;
      }
   }

   Console::WriteLine();
}

/*
This example produces the following results:
All occurrences of 'he' from position 66 to 0.
0----+----1----+----2----+----3----+----4----+----5----+----6----+-
0123456789012345678901234567890123456789012345678901234567890123456
Now is the time for all good men to come to the aid of their party.

The string 'he' occurs at position(s):  56  45  8
*/
// Sample for String.LastIndexOf(String, Int32)
using System;

class Sample {
    public static void Main() {

    string br1 = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-";
    string br2 = "0123456789012345678901234567890123456789012345678901234567890123456";
    string str = "Now is the time for all good men to come to the aid of their party.";
    int start;
    int at;

    start = str.Length-1;
    Console.WriteLine("All occurrences of 'he' from position {0} to 0.", start);
    Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str);
    Console.Write("The string 'he' occurs at position(s): ");

    at = 0;
    while((start > -1) && (at > -1))
        {
        at = str.LastIndexOf("he", start);
        if (at > -1)
            {
            Console.Write("{0} ", at);
            start = at - 1;
            }
        }
    Console.Write("{0}{0}{0}", Environment.NewLine);
    }
}
/*
This example produces the following results:
All occurrences of 'he' from position 66 to 0.
0----+----1----+----2----+----3----+----4----+----5----+----6----+-
0123456789012345678901234567890123456789012345678901234567890123456
Now is the time for all good men to come to the aid of their party.

The string 'he' occurs at position(s): 56 45 8


*/
' Sample for String.LastIndexOf(String, Int32)
 _

Class Sample
   
   Public Shared Sub Main()
      
      Dim br1 As String = "0----+----1----+----2----+----3----+----4----+----5----+----6----+-"
      Dim br2 As String = "0123456789012345678901234567890123456789012345678901234567890123456"
      Dim str As String = "Now is the time for all good men to come to the aid of their party."
      Dim start As Integer
      Dim at As Integer

      '#3
      start = str.Length - 1
      Console.WriteLine("All occurrences of 'he' from position {0} to 0.", start)
      Console.WriteLine("{1}{0}{2}{0}{3}{0}", Environment.NewLine, br1, br2, str)
      Console.Write("The string 'he' occurs at position(s): ")
      
      at = 0
      While start > - 1 And at > - 1
         at = str.LastIndexOf("he", start)
         If at > - 1 Then
            Console.Write("{0} ", at)
            start = at - 1
         End If
      End While
      Console.Write("{0}{0}{0}", Environment.NewLine)
   End Sub
End Class
'
'This example produces the following results:
'All occurrences of 'he' from position 66 to 0.
'0----+----1----+----2----+----3----+----4----+----5----+----6----+-
'0123456789012345678901234567890123456789012345678901234567890123456
'Now is the time for all good men to come to the aid of their party.
'
'The string 'he' occurs at position(s): 56 45 8
'
'

Remarques

La numérotation d’index commence à zéro.Index numbering starts from zero. Autrement dit, le premier caractère de la chaîne se trouve à l’index zéro et le dernier à Length-1.That is, the first character in the string is at index zero and the last is at Length - 1.

La recherche commence à la position de caractère startIndex de cette instance et se poursuit vers le début jusqu’à ce que value soit trouvé ou que la première position de caractère ait été examinée.The search begins at the startIndex character position of this instance and proceeds backward toward the beginning until either value is found or the first character position has been examined. Par exemple, si startIndex est Length-1, la méthode recherche le début de chaque caractère à partir du dernier caractère de la chaîne.For example, if startIndex is Length - 1, the method searches every character from the last character in the string to the beginning.

Cette méthode effectue une recherche de mot (respectant la casse et dépendante de la culture) à l’aide de la culture actuelle.This method performs a word (case-sensitive and culture-sensitive) search using the current culture.

Les jeux de caractères incluent les caractères ignorables, à savoir les caractères qui ne sont pas considérés lors de l'exécution d'une comparaison linguistique ou dépendante de la culture.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. Dans une recherche dépendante de la culture, si value contient un caractère ignorable, le résultat est équivalent à la recherche avec ce caractère supprimé.In a culture-sensitive search, if value contains an ignorable character, the result is equivalent to searching with that character removed. Si value se compose uniquement d’un ou de plusieurs caractères pouvant être ignorés, la méthode LastIndexOf(String, Int32) retourne toujours startIndex, qui est la position de caractère à laquelle la recherche commence.If value consists only of one or more ignorable characters, the LastIndexOf(String, Int32) method always returns startIndex, which is the character position at which the search begins. Dans l’exemple suivant, la méthode LastIndexOf(String, Int32) est utilisée pour rechercher une sous-chaîne qui comprend un trait d’union conditionnel (U + 00AD) et qui précède ou comprend le « m » final dans une chaîne.In the following example, the LastIndexOf(String, Int32) method is used to find a substring that includes a soft hyphen (U+00AD) and that precedes or includes the final "m" in a string. Si l’exemple est exécuté sur la .NET Framework 4.NET Framework 4 ou une version ultérieure, étant donné que le trait d’union conditionnel dans la chaîne de recherche est ignoré, l’appel de la méthode pour rechercher une sous-chaîne composée du trait d’union conditionnel et de « m » retourne la position du « m » dans la chaîne, tandis que l’appeler pour trouver une sous-chaîne composée du trait d’union conditionnel et « n » retourne la position du « n ».If the example is run on the .NET Framework 4.NET Framework 4 or later, because the soft hyphen in the search string is ignored, calling the method to find a substring that consists of the soft hyphen and "m" returns the position of the "m" in the string, whereas calling it to find a substring that consists of the soft hyphen and "n" returns the position of the "n". Lorsque la chaîne de recherche contient uniquement le trait d’union conditionnel, la méthode retourne l’index du « m », qui représente la valeur de startIndex.When the search string contains only the soft hyphen, the method returns the index of the "m", which represents the value of startIndex.

using System;

public class Example
{
   public static void Main()
   {
      int position = 0;
      string s1 = "ani\u00ADmal";
      string s2 = "animal";
      
      // Find the index of the soft hyphen.
      position = s1.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)
         Console.WriteLine(s1.LastIndexOf("\u00AD", position));

      position = s2.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)   
         Console.WriteLine(s2.LastIndexOf("\u00AD", position));
      
      // Find the index of the soft hyphen followed by "n".
      position = s1.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)
         Console.WriteLine(s1.LastIndexOf("\u00ADn", position));

      position = s2.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)   
         Console.WriteLine(s2.LastIndexOf("\u00ADn", position));
      
      // Find the index of the soft hyphen followed by "m".
      position = s1.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)
         Console.WriteLine(s1.LastIndexOf("\u00ADm", position));

      position = s2.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)   
         Console.WriteLine(s2.LastIndexOf("\u00ADm", position));
   }
}
// The example displays the following output:
//       'm' at position 4
//       4
//       'm' at position 3
//       3
//       'm' at position 4
//       1
//       'm' at position 3
//       1
//       'm' at position 4
//       4
//       'm' at position 3
//       3
Module Example
   Public Sub Main()
      Dim position As Integer
      Dim softHyphen As String = ChrW(&h00AD)
      Dim s1 As String = "ani" + softHyphen + "mal"
      Dim s2 As String = "animal"
      
      ' Find the index of the soft hyphen.
      position = s1.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s1.LastIndexOf(softHyphen, position))
      End If
         
      position = s2.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s2.LastIndexOf(softHyphen, position))
      End If
      
      ' Find the index of the soft hyphen followed by "n".
      position = s1.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s1.LastIndexOf(softHyphen + "n", position))
      End If
         
      position = s2.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s2.LastIndexOf(softHyphen + "n", position))
      End If
      
      ' Find the index of the soft hyphen followed by "m".
      position = s1.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s1.LastIndexOf(softHyphen + "m", position))
      End If
      
      position = s2.LastIndexOf("m")
      Console.WriteLine("'m' at position {0}", position)
      If position >= 0 Then
         Console.WriteLine(s2.LastIndexOf(softHyphen + "m", position))
      End If
   End Sub
End Module
' The example displays the following output:
'       'm' at position 4
'       4
'       'm' at position 3
'       3
'       'm' at position 4
'       1
'       'm' at position 3
'       1
'       'm' at position 4
'       4
'       'm' at position 3
'       3

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 substituent des valeurs par défaut et appellent à la place des méthodes qui requièrent que des paramètres soient explicitement spécifiés.As explained in Best Practices for Using Strings, we recommend that you avoid calling string comparison methods that substitute default values and instead call methods that require parameters to be explicitly specified. Pour Rechercher l’index d’une sous-chaîne qui précède une position de caractère particulière à l’aide des règles de comparaison de la culture actuelle, appelez la surcharge de méthode LastIndexOf(String, Int32, StringComparison) avec la valeur CurrentCulture pour son paramètre comparisonType.To find the index of a substring that precedes a particular character position by using the comparison rules of the current culture, call the LastIndexOf(String, Int32, StringComparison) method overload with a value of CurrentCulture for its comparisonType parameter.

Voir aussi

S’applique à