String.LastIndexOf String.LastIndexOf String.LastIndexOf String.LastIndexOf Method

Definición

Indica la posición de índice de base cero de la última aparición de un carácter Unicode especificado o de una cadena en la instancia en cuestión.Reports the zero-based index position of the last occurrence of a specified Unicode character or string within this instance. El método devuelve -1, si el carácter o cadena no se encuentran en esta instancia.The method returns -1 if the character or string is not found in this instance.

Sobrecargas

LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison)

Devuelve el índice de base cero de la última aparición de una cadena especificada dentro del objeto String actual.Reports the zero-based index of the last occurrence of a specified string within the current String object. La búsqueda se inicia en una posición de carácter especificada y continúa hacia atrás hacia el principio de la cadena.The search starts at a specified character position and proceeds backward toward the beginning of the string. Un parámetro especifica el tipo de comparación que se debe realizar cuando se busca la cadena especificada.A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32)

Indica la posición de índice de base cero de la última aparición de una cadena especificada en la instancia en cuestión.Reports the zero-based index position of the last occurrence of a specified string within this instance. La búsqueda se inicia en una posición de caracteres especificada y continúa hacia atrás hacia el principio de la cadena durante un número especificado de posiciones de caracteres.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) LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32)

Devuelve la posición de índice de base cero de la última aparición del carácter Unicode especificado en una subcadena de la instancia.Reports the zero-based index position of the last occurrence of the specified Unicode character in a substring within this instance. La búsqueda se inicia en una posición de caracteres especificada y continúa hacia atrás hacia el principio de la cadena durante un número especificado de posiciones de caracteres.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) LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison)

Devuelve el índice de base cero de la última aparición de una cadena especificada dentro del objeto String actual.Reports the zero-based index of the last occurrence of a specified string within the current String object. Un parámetro especifica el tipo de búsqueda que se va a usar para la cadena especificada.A parameter specifies the type of search to use for the specified string.

LastIndexOf(Char) LastIndexOf(Char) LastIndexOf(Char) LastIndexOf(Char)

Devuelve la posición de índice de base cero de la última aparición de un carácter Unicode especificado en la instancia.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance.

LastIndexOf(Char, Int32) LastIndexOf(Char, Int32) LastIndexOf(Char, Int32) LastIndexOf(Char, Int32)

Devuelve la posición de índice de base cero de la última aparición de un carácter Unicode especificado en la instancia.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance. La búsqueda se inicia en una posición de carácter especificada y continúa hacia atrás hacia el principio de la cadena.The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(String) LastIndexOf(String) LastIndexOf(String) LastIndexOf(String)

Indica la posición de índice de base cero de la última aparición de una cadena especificada en la instancia en cuestión.Reports the zero-based index position of the last occurrence of a specified string within this instance.

LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison)

Indica la posición de índice de base cero de la última aparición de una cadena especificada en la instancia en cuestión.Reports the zero-based index position of the last occurrence of a specified string within this instance. La búsqueda se inicia en una posición de caracteres especificada y continúa hacia atrás hacia el principio de la cadena durante el número especificado de posiciones de caracteres.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 parámetro especifica el tipo de comparación que se debe realizar cuando se busca la cadena especificada.A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, Int32) LastIndexOf(String, Int32) LastIndexOf(String, Int32) LastIndexOf(String, Int32)

Indica la posición de índice de base cero de la última aparición de una cadena especificada en la instancia en cuestión.Reports the zero-based index position of the last occurrence of a specified string within this instance. La búsqueda se inicia en una posición de carácter especificada y continúa hacia atrás hacia el principio de la cadena.The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison)

Devuelve el índice de base cero de la última aparición de una cadena especificada dentro del objeto String actual.Reports the zero-based index of the last occurrence of a specified string within the current String object. La búsqueda se inicia en una posición de carácter especificada y continúa hacia atrás hacia el principio de la cadena.The search starts at a specified character position and proceeds backward toward the beginning of the string. Un parámetro especifica el tipo de comparación que se debe realizar cuando se busca la cadena especificada.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

Parámetros

value
String String String String

Cadena que se va a buscar.The string to seek.

startIndex
Int32 Int32 Int32 Int32

Posición en la que comienza la búsqueda.The search starting position. La búsqueda continúa desde startIndex hacia el principio de esta instancia.The search proceeds from startIndex toward the beginning of this instance.

comparisonType
StringComparison StringComparison StringComparison StringComparison

Uno de los valores de enumeración que especifica las reglas de la búsqueda.One of the enumeration values that specifies the rules for the search.

Devoluciones

Posición del índice de inicio de base cero del parámetro value, si se encuentra esa cadena, o -1 si no se encuentra o si la instancia actual es igual que 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 es Empty, el valor devuelto es el menor de startIndex y la última posición de índice de esta instancia.If value is Empty, the return value is the smaller of startIndex and the last index position in this instance.

Excepciones

La instancia actual no es igual a Empty y startIndex es menor que cero o mayor que la longitud de la instancia actual.The current instance does not equal Empty, and startIndex is less than zero or greater than the length of the current instance.

O bien-or- La instancia actual es igual a Empty y startIndex es menor que -1 o mayor que cero.The current instance equals Empty, and startIndex is less than -1 or greater than zero.

comparisonType no es un valor StringComparison válido.comparisonType is not a valid StringComparison value.

Ejemplos

En el ejemplo siguiente se muestran tres sobrecargas LastIndexOf del método que buscan la última aparición de una cadena dentro de otra cadena usando valores diferentes StringComparison de la enumeración.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
'

Comentarios

La numeración de índices comienza en cero.Index numbering starts from zero. Es decir, el primer carácter de la cadena está en el índice cero y el último en Length -1.That is, the first character in the string is at index zero and the last is at Length - 1.

La búsqueda comienza en la startIndex posición del carácter y continúa hacia atrás value hasta que se encuentra o hasta que se examina la primera posición del carácter.The search begins at the startIndex character position and proceeds backward until either value is found or the first character position has been examined. Por ejemplo, si startIndex es Length -1, el método busca en cada carácter desde el último carácter de la cadena hasta el principio.For example, if startIndex is Length - 1, the method searches every character from the last character in the string to the beginning.

El comparisonType parámetro especifica que se busque el value parámetro con la referencia cultural actual o invariable, mediante una búsqueda con distinción de mayúsculas y minúsculas o sin distinción de mayúsculas y minúsculas, y con reglas de comparación de palabras o 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.

Notas a los autores de las llamadas

Los juegos de caracteres incluyen caracteres que se pueden pasar por alto, que son los caracteres que no se tienen en cuenta al realizar una comparación lingüística o en la que se tiene en cuenta la referencia cultural.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. En una búsqueda que tiene en cuenta la referencia cultural (es decir, si comparisonType no es Ordinal o OrdinalIgnoreCase), si value contiene un carácter que se puede pasar por alto, el resultado es equivalente a buscar sin ese carácter.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 consta solo de uno o más caracteres que se pueden omitir, el startIndex LastIndexOf(String, Int32, StringComparison) método siempre devuelve, que es la posición del carácter en la que comienza la búsqueda.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.

En el ejemplo siguiente, el LastIndexOf(String, Int32, StringComparison) método se usa para buscar la posición de un guión blando (U + 00AD) seguido de una "m", comenzando por la "m" final de dos cadenas.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. Solo una de las cadenas contiene la subcadena necesaria.Only one of the strings contains the required substring. Si el ejemplo se ejecuta en .NET Framework 4.NET Framework 4 o versiones posteriores, en ambos casos, dado que el guion blando es un carácter que se debe omitir, el método devuelve el índice de "m" en la cadena cuando realiza una comparación dependiente de la referencia cultural.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. Observe que en el caso de la primera cadena, que incluye el guion virtual seguido de una "m", el método no devuelve el índice del guion virtual, sino el índice de "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". El método devuelve el índice del guion virtual de la primera cadena solo cuando realiza una comparación ordinal.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) LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32)

Indica la posición de índice de base cero de la última aparición de una cadena especificada en la instancia en cuestión.Reports the zero-based index position of the last occurrence of a specified string within this instance. La búsqueda se inicia en una posición de caracteres especificada y continúa hacia atrás hacia el principio de la cadena durante un número especificado de posiciones de caracteres.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

Parámetros

value
String String String String

Cadena que se va a buscar.The string to seek.

startIndex
Int32 Int32 Int32 Int32

Posición en la que comienza la búsqueda.The search starting position. La búsqueda continúa desde startIndex hacia el principio de esta instancia.The search proceeds from startIndex toward the beginning of this instance.

count
Int32 Int32 Int32 Int32

Número de posiciones de caracteres que se van a examinar.The number of character positions to examine.

Devoluciones

Posición del índice de inicio de base cero de value, si se encuentra esa cadena, o -1 si no se encuentra o si la instancia actual es igual que 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 es Empty, el valor devuelto es el menor de startIndex y la última posición de índice de esta instancia.If value is Empty, the return value is the smaller of startIndex and the last index position in this instance.

Excepciones

count es negativo.count is negative.

o bien-or- La instancia actual no es igual a Empty y startIndex es negativo.The current instance does not equal Empty, and startIndex is negative.

o bien-or- La instancia actual no es igual a Empty y startIndex es mayor que la longitud de esta instancia.The current instance does not equal Empty, and startIndex is greater than the length of this instance.

O bien-or- La instancia actual no es igual a Empty y startIndex - count+ 1 especifica una posición que no se encuentra dentro de esta instancia.The current instance does not equal Empty, and startIndex - count+ 1 specifies a position that is not within this instance.

O bien-or- La instancia actual es igual a Empty y start es menor que -1 o mayor que cero.The current instance equals Empty and start is less than -1 or greater than zero.

O bien-or- La instancia actual es igual a Empty y count es mayor que 1.The current instance equals Empty and count is greater than 1.

Ejemplos

En el ejemplo siguiente se busca el índice de todas las apariciones de una cadena en una subcadena, que se trabaja desde el final de la subcadena hasta el inicio de la subcadena.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
'
'

Comentarios

La numeración de índices comienza en cero.Index numbering starts from zero. Es decir, el primer carácter de la cadena está en el índice cero y el último en Length -1.That is, the first character in the string is at index zero and the last is at Length - 1.

La búsqueda comienza en la startIndex posición de carácter de esta instancia y continúa hacia atrás hacia el principio value hasta que se encuentra count o se examinan las posiciones de los caracteres.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. Por ejemplo, si startIndex es Length -1, el método busca en count los caracteres hacia atrás desde el último carácter de la cadena.For example, if startIndex is Length - 1, the method searches backward count characters from the last character in the string.

Este método realiza una búsqueda de palabras (con distinción de mayúsculas y minúsculas y con la referencia cultural) que usa la referencia cultural actual.This method performs a word (case-sensitive and culture-sensitive) search using the current culture.

Los juegos de caracteres incluyen caracteres que se pueden pasar por alto, que son los caracteres que no se tienen en cuenta al realizar una comparación lingüística o en la que se tiene en cuenta la referencia cultural.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. En una búsqueda que tiene en cuenta la referencia cultural, si value contiene un carácter que se puede pasar por alto, el resultado es equivalente a buscar sin ese carácter.In a culture-sensitive search, if value contains an ignorable character, the result is equivalent to searching with that character removed. Si value consta solo de uno o más caracteres que se pueden omitir, el startIndex LastIndexOf método siempre devuelve, que es la posición del carácter en la que comienza la búsqueda.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. En el ejemplo siguiente, el LastIndexOf método se usa para buscar la posición de un guión blando (U + 00AD) en los dos caracteres que preceden a la "m" final de dos cadenas.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. Solo una de las cadenas contiene la subcadena necesaria.Only one of the strings contains the required substring. Si el ejemplo se ejecuta en .NET Framework 4.NET Framework 4 o versiones posteriores, en ambos casos, dado que el guion blando es un carácter que se debe omitir, el método devuelve el índice de "m" en la cadena cuando realiza una comparación dependiente de la referencia cultural.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. Observe que en el caso de la primera cadena, que incluye el guion virtual seguido de una "m", el método no devuelve el índice del guion virtual, sino el índice de "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

Notas a los autores de las llamadas

Como se explica en procedimientos recomendados para el uso de cadenas, se recomienda evitar llamar a métodos de comparación de cadenas que sustituyan los valores predeterminados y, en su lugar, llamar a métodos que requieran que los parámetros se especifiquen explícitamente.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. Para realizar esta operación utilizando las reglas de comparación de la referencia cultural actual, llame LastIndexOf(String, Int32, Int32, StringComparison) a la sobrecarga del método con CurrentCulture un valor comparisonType de para su parámetro.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.

Consulte también:

LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32)

Devuelve la posición de índice de base cero de la última aparición del carácter Unicode especificado en una subcadena de la instancia.Reports the zero-based index position of the last occurrence of the specified Unicode character in a substring within this instance. La búsqueda se inicia en una posición de caracteres especificada y continúa hacia atrás hacia el principio de la cadena durante un número especificado de posiciones de caracteres.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

Parámetros

value
Char Char Char Char

Carácter Unicode que se va a buscar.The Unicode character to seek.

startIndex
Int32 Int32 Int32 Int32

Posición inicial de la búsqueda.The starting position of the search. La búsqueda continúa desde startIndex hacia el principio de esta instancia.The search proceeds from startIndex toward the beginning of this instance.

count
Int32 Int32 Int32 Int32

Número de posiciones de caracteres que se van a examinar.The number of character positions to examine.

Devoluciones

Posición del índice de base cero de value, si se encuentra ese carácter, o -1 si no se encuentra o si la instancia actual es igual que 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.

Excepciones

La instancia actual no es igual a Empty y startIndex es menor que cero o mayor o igual que la longitud de esta instancia.The current instance does not equal Empty, and startIndex is less than zero or greater than or equal to the length of this instance.

O bien-or- La instancia actual no es igual a Empty y startIndex - count + 1 es inferior a cero.The current instance does not equal Empty, and startIndex - count + 1 is less than zero.

Ejemplos

En el ejemplo siguiente se busca el índice de todas las apariciones de un carácter en una subcadena, que se trabaja desde el final de la subcadena hasta el principio de la subcadena.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
'
'

Comentarios

La numeración de índices comienza en cero.Index numbering starts from zero. Es decir, el primer carácter de la cadena está en el índice cero y el último en Length -1.That is, the first character in the string is at index zero and the last is at Length - 1.

Este método comienza a buscar en startIndex la posición de carácter y continúa hacia atrás hacia el principio de esta instancia value hasta que se count encuentre o se hayan examinado posiciones de caracteres.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. Por ejemplo, si startIndex es Length -1, el método busca en count los caracteres hacia atrás desde el último carácter de la cadena.For example, if startIndex is Length - 1, the method searches backward count characters from the last character in the string. La búsqueda distingue mayúsculas de minúsculas.The search is case-sensitive.

Este método realiza una búsqueda ordinal (sin tener en cuenta la referencia cultural), donde un carácter se considera equivalente a otro carácter solo si su valor escalar Unicode es el mismo.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. Para realizar una búsqueda dependiente de la referencia cultural, CompareInfo.LastIndexOf use el método, donde un valor escalar Unicode que representa un carácter precompuesto, como la ligadura "Æ" (U + 00C6), podría considerarse equivalente a cualquier aparición de los componentes del carácter en el secuencia correcta, como "AE" (U + 0041, U + 0045), dependiendo de la referencia cultural.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.

Consulte también:

LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison)

Devuelve el índice de base cero de la última aparición de una cadena especificada dentro del objeto String actual.Reports the zero-based index of the last occurrence of a specified string within the current String object. Un parámetro especifica el tipo de búsqueda que se va a usar para la cadena especificada.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

Parámetros

value
String String String String

Cadena que se va a buscar.The string to seek.

comparisonType
StringComparison StringComparison StringComparison StringComparison

Uno de los valores de enumeración que especifica las reglas de la búsqueda.One of the enumeration values that specifies the rules for the search.

Devoluciones

Devuelve la posición de índice inicial de base cero del parámetro value si se encuentra dicha cadena; de lo contrario, devuelve -1.The zero-based starting index position of the value parameter if that string is found, or -1 if it is not. Si value es Empty, el valor devuelto es la última posición de índice en esta instancia.If value is Empty, the return value is the last index position in this instance.

Excepciones

comparisonType no es un valor StringComparison válido.comparisonType is not a valid StringComparison value.

Ejemplos

En el ejemplo siguiente se muestran tres sobrecargas LastIndexOf del método que buscan la última aparición de una cadena dentro de otra cadena usando valores diferentes StringComparison de la enumeración.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
'

Comentarios

La numeración de índices comienza en cero.Index numbering starts from zero. Es decir, el primer carácter de la cadena está en el índice cero y el último en Length -1.That is, the first character in the string is at index zero and the last is at Length - 1.

El comparisonType parámetro especifica que se busque el value parámetro con la referencia cultural actual o invariable, mediante una búsqueda con distinción de mayúsculas y minúsculas o sin distinción de mayúsculas y minúsculas, y con reglas de comparación de palabras o 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 búsqueda comienza en la posición del último carácter de esta instancia y continúa hacia atrás hacia el principio hasta value que se encuentra o hasta que se examina la primera posición del carácter.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.

Notas a los autores de las llamadas

Los juegos de caracteres incluyen caracteres que se pueden pasar por alto, que son los caracteres que no se tienen en cuenta al realizar una comparación lingüística o en la que se tiene en cuenta la referencia cultural.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. En una búsqueda que tiene en cuenta la referencia cultural (es decir, si options no es Ordinal o OrdinalIgnoreCase), si value contiene un carácter que se puede pasar por alto, el resultado es equivalente a buscar sin ese carácter.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 consta solo de uno o más caracteres que se van a LastIndexOf(String, StringComparison) omitir, Length el método siempre devuelve-1, que representa la última posición de índice en la instancia actual.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.

En el ejemplo siguiente, el LastIndexOf(String, StringComparison) método se usa para buscar tres subcadenas (un guion blando (U + 00AD), un guion flexible seguido de "n" y un guion flexible seguido de "m") en dos cadenas.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. Solo una de las cadenas contiene un guion virtual.Only one of the strings contains a soft hyphen. Si el ejemplo se ejecuta en .NET Framework 4.NET Framework 4 o versiones posteriores, dado que el guion blando es un carácter que se puede pasar por alto, una búsqueda dependiente de la referencia cultural devuelve el mismo valor que devolvería si el guion no estuviera incluido en la cadena de búsqueda.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. Sin embargo, una búsqueda ordinal busca correctamente el guion flexible en una cadena e informa de que no está presente en la segunda cadena.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) LastIndexOf(Char) LastIndexOf(Char) LastIndexOf(Char)

Devuelve la posición de índice de base cero de la última aparición de un carácter Unicode especificado en la instancia.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

Parámetros

value
Char Char Char Char

Carácter Unicode que se va a buscar.The Unicode character to seek.

Devoluciones

Devuelve la posición de índice de base cero de value si se encuentra dicho carácter; de lo contrario, devuelve -1.The zero-based index position of value if that character is found, or -1 if it is not.

Ejemplos

En el ejemplo siguiente se ExtractFilename define un método que LastIndexOf(Char) utiliza el método para buscar el último carácter separador de directorio en una cadena y extraer el nombre de archivo de la cadena.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 el archivo existe, el método devuelve el nombre de archivo sin su ruta de acceso.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

Comentarios

La numeración de índices comienza en cero.Index numbering starts from zero. Es decir, el primer carácter de la cadena está en el índice cero y el último en Length -1.That is, the first character in the string is at index zero and the last is at Length - 1.

Este método comienza a buscar en la última posición de carácter de esta instancia y continúa hacia atrás hacia el principio value hasta que se encuentra o se examina la primera posición de carácter.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 búsqueda distingue mayúsculas de minúsculas.The search is case-sensitive.

Este método realiza una búsqueda ordinal (sin tener en cuenta la referencia cultural), donde un carácter se considera equivalente a otro carácter solo si sus valores escalares Unicode son iguales.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. Para realizar una búsqueda dependiente de la referencia cultural, CompareInfo.LastIndexOf use el método, donde un valor escalar Unicode que representa un carácter precompuesto, como la ligadura "Æ" (U + 00C6), podría considerarse equivalente a cualquier aparición de los componentes del carácter en el secuencia correcta, como "AE" (U + 0041, U + 0045), dependiendo de la referencia cultural.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.

Consulte también:

LastIndexOf(Char, Int32) LastIndexOf(Char, Int32) LastIndexOf(Char, Int32) LastIndexOf(Char, Int32)

Devuelve la posición de índice de base cero de la última aparición de un carácter Unicode especificado en la instancia.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance. La búsqueda se inicia en una posición de carácter especificada y continúa hacia atrás hacia el principio de la cadena.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

Parámetros

value
Char Char Char Char

Carácter Unicode que se va a buscar.The Unicode character to seek.

startIndex
Int32 Int32 Int32 Int32

Posición inicial de la búsqueda.The starting position of the search. La búsqueda continúa desde startIndex hacia el principio de esta instancia.The search proceeds from startIndex toward the beginning of this instance.

Devoluciones

Posición del índice de base cero de value, si se encuentra ese carácter, o -1 si no se encuentra o si la instancia actual es igual que 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.

Excepciones

La instancia actual no es igual a Empty y startIndex es menor que cero o mayor o igual que la longitud de esta instancia.The current instance does not equal Empty, and startIndex is less than zero or greater than or equal to the length of this instance.

Ejemplos

En el ejemplo siguiente se busca el índice de todas las apariciones de un carácter en una cadena, desde el final de la cadena hasta el inicio de la cadena.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
'

Comentarios

La numeración de índices comienza en cero.Index numbering starts from zero. Es decir, el primer carácter de la cadena está en el índice cero y el último en Length -1. este método comienza a buscar en startIndex la posición de carácter de esta instancia y continúa hacia atrás hacia el principio de la instancia actual hasta que value se encuentra o se ha examinado la primera posición de carácter.That is, the first character in the string is at index zero and the last is at Length - 1.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. Por ejemplo, si startIndex es Length -1, el método busca en cada carácter desde el último carácter de la cadena hasta el principio.For example, if startIndex is Length - 1, the method searches every character from the last character in the string to the beginning. La búsqueda distingue mayúsculas de minúsculas.The search is case-sensitive.

Este método realiza una búsqueda ordinal (sin tener en cuenta la referencia cultural), donde un carácter se considera equivalente a otro carácter solo si sus valores escalares Unicode son iguales.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. Para realizar una búsqueda dependiente de la referencia cultural, CompareInfo.LastIndexOf use el método, donde un valor escalar Unicode que representa un carácter precompuesto, como la ligadura "Æ" (U + 00C6), podría considerarse equivalente a cualquier aparición de los componentes del carácter en el secuencia correcta, como "AE" (U + 0041, U + 0045), dependiendo de la referencia cultural.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.

Consulte también:

LastIndexOf(String) LastIndexOf(String) LastIndexOf(String) LastIndexOf(String)

Indica la posición de índice de base cero de la última aparición de una cadena especificada en la instancia en cuestión.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

Parámetros

value
String String String String

Cadena que se va a buscar.The string to seek.

Devoluciones

Devuelve la posición de índice inicial de base cero de value si se encuentra dicha cadena; de lo contrario, devuelve -1.The zero-based starting index position of value if that string is found, or -1 if it is not. Si value es Empty, el valor devuelto es la última posición de índice en esta instancia.If value is Empty, the return value is the last index position in this instance.

Excepciones

Ejemplos

En el ejemplo siguiente se quitan las etiquetas HTML de apertura y cierre de una cadena si las etiquetas comienzan y finalizan la cadena.The following example removes opening and closing HTML tags from a string if the tags begin and end the string. Si una cadena termina con un carácter de corchete de cierre (">"), LastIndexOf el ejemplo usa el método para buscar el inicio de la etiqueta de cierre.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>

Comentarios

La numeración de índices comienza en cero.Index numbering starts from zero. Es decir, el primer carácter de la cadena está en el índice cero y el último en Length -1.That is, the first character in the string is at index zero and the last is at Length - 1.

La búsqueda comienza en la posición del último carácter de esta instancia y continúa hacia atrás hacia el principio hasta value que se encuentra o hasta que se examina la primera posición del carácter.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.

Este método realiza una búsqueda de palabras (con distinción de mayúsculas y minúsculas y con la referencia cultural) que usa la referencia cultural actual.This method performs a word (case-sensitive and culture-sensitive) search using the current culture.

Los juegos de caracteres incluyen caracteres que se pueden pasar por alto, que son los caracteres que no se tienen en cuenta al realizar una comparación lingüística o en la que se tiene en cuenta la referencia cultural.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. En una búsqueda que tiene en cuenta la referencia cultural, si value contiene un carácter que se puede pasar por alto, el resultado es equivalente a buscar sin ese carácter.In a culture-sensitive search, if value contains an ignorable character, the result is equivalent to searching with that character removed. Si value consta solo de uno o más caracteres que se van a LastIndexOf(String) omitir, String.Length el método siempre devuelve-1, que representa la última posición de índice en la instancia actual.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. En el ejemplo siguiente, el LastIndexOf(String) método se usa para buscar tres subcadenas (un guion blando (U + 00AD), un guion flexible seguido de "n" y un guion flexible seguido de "m") en dos cadenas.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. Solo una de las cadenas contiene un guion virtual.Only one of the strings contains a soft hyphen. Si el ejemplo se ejecuta en .NET Framework 4.NET Framework 4 o versiones posteriores, en cada caso, dado que el guion blando es un carácter que se debe omitir, el resultado es el mismo que si el guion no se hubiera incluido en. valueIf 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. Al buscar un guion flexible únicamente, el método devuelve 6 y 5.When searching for a soft hyphen only, the method returns 6 and 5. Estos valores se corresponden con el índice del último carácter de las dos cadenas.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

Notas a los autores de las llamadas

Como se explica en procedimientos recomendados para el uso de cadenas, se recomienda evitar llamar a métodos de comparación de cadenas que sustituyan los valores predeterminados y, en su lugar, llamar a métodos que requieran que los parámetros se especifiquen explícitamente.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. Para buscar el último índice de una subcadena dentro de una instancia de cadena usando las reglas de comparación de la referencia cultural actual LastIndexOf(String, StringComparison) , llame a la sobrecarga del CurrentCulture método con comparisonType un valor de para su parámetro.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.

Consulte también:

LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison)

Indica la posición de índice de base cero de la última aparición de una cadena especificada en la instancia en cuestión.Reports the zero-based index position of the last occurrence of a specified string within this instance. La búsqueda se inicia en una posición de caracteres especificada y continúa hacia atrás hacia el principio de la cadena durante el número especificado de posiciones de caracteres.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 parámetro especifica el tipo de comparación que se debe realizar cuando se busca la cadena especificada.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

Parámetros

value
String String String String

Cadena que se va a buscar.The string to seek.

startIndex
Int32 Int32 Int32 Int32

Posición en la que comienza la búsqueda.The search starting position. La búsqueda continúa desde startIndex hacia el principio de esta instancia.The search proceeds from startIndex toward the beginning of this instance.

count
Int32 Int32 Int32 Int32

Número de posiciones de caracteres que se van a examinar.The number of character positions to examine.

comparisonType
StringComparison StringComparison StringComparison StringComparison

Uno de los valores de enumeración que especifica las reglas de la búsqueda.One of the enumeration values that specifies the rules for the search.

Devoluciones

Posición del índice de inicio de base cero del parámetro value, si se encuentra esa cadena, o -1 si no se encuentra o si la instancia actual es igual que 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 es Empty, el valor devuelto es el menor de startIndex y la última posición de índice de esta instancia.If value is Empty, the return value is the smaller of startIndex and the last index position in this instance.

Excepciones

count es negativo.count is negative.

O bien-or- La instancia actual no es igual a Empty y startIndex es negativo.The current instance does not equal Empty, and startIndex is negative.

O bien-or- La instancia actual no es igual a Empty y startIndex es mayor que la longitud de esta instancia.The current instance does not equal Empty, and startIndex is greater than the length of this instance.

O bien-or- La instancia actual no es igual a Empty, y startIndex + 1 - count especifica una posición que no se encuentra dentro de esta instancia.The current instance does not equal Empty, and startIndex + 1 - count specifies a position that is not within this instance.

o bien-or- La instancia actual es igual a Empty y start es menor que -1 o mayor que cero.The current instance equals Empty and start is less than -1 or greater than zero.

O bien-or- La instancia actual es igual a Empty y count es mayor que 1.The current instance equals Empty and count is greater than 1.

comparisonType no es un valor StringComparison válido.comparisonType is not a valid StringComparison value.

Ejemplos

En el ejemplo siguiente se muestran tres sobrecargas LastIndexOf del método que buscan la última aparición de una cadena dentro de otra cadena usando valores diferentes StringComparison de la enumeración.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
'

Comentarios

La numeración de índices comienza en cero.Index numbering starts from zero. Es decir, el primer carácter de la cadena está en el índice cero y el último en Length -1.That is, the first character in the string is at index zero and the last is at Length - 1.

La búsqueda comienza en la startIndex posición de carácter y continúa hacia atrás value hasta que se encuentra count o se examinan las posiciones de los caracteres.The search begins at the startIndex character position and proceeds backward until either value is found or count character positions have been examined. Por ejemplo, si startIndex es Length -1, el método busca en count los caracteres hacia atrás desde el último carácter de la cadena.For example, if startIndex is Length - 1, the method searches backward count characters from the last character in the string.

El comparisonType parámetro especifica que se busque el value parámetro con la referencia cultural actual o invariable, mediante una búsqueda con distinción de mayúsculas y minúsculas o sin distinción de mayúsculas y minúsculas, y con reglas de comparación de palabras o 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.

Notas a los autores de las llamadas

Los juegos de caracteres incluyen caracteres que se pueden pasar por alto, que son los caracteres que no se tienen en cuenta al realizar una comparación lingüística o en la que se tiene en cuenta la referencia cultural.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. En una búsqueda que tiene en cuenta la referencia cultural (es decir, si comparisonType no es Ordinal o OrdinalIgnoreCase), si value contiene un carácter que se puede pasar por alto, el resultado es equivalente a buscar sin ese carácter.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 consta solo de uno o más caracteres que se pueden omitir, el startIndex LastIndexOf(String, Int32, Int32, StringComparison) método siempre devuelve, que es la posición del carácter en la que comienza la búsqueda.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.

En el ejemplo siguiente, el LastIndexOf(String, Int32, Int32, StringComparison) método se usa para buscar la posición de un guion blando (U + 00AD) seguido de una "m" en todas las cadenas excepto en la primera posición de los caracteres antes de la "m" final de dos cadenas.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. Solo una de las cadenas contiene la subcadena necesaria.Only one of the strings contains the required substring. Si el ejemplo se ejecuta en .NET Framework 4.NET Framework 4 o versiones posteriores, en ambos casos, dado que el guion blando es un carácter que se debe omitir, el método devuelve el índice de "m" en la cadena cuando realiza una comparación dependiente de la referencia cultural.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. Sin embargo, cuando realiza una comparación ordinal, encuentra la subcadena solo en la primera cadena.When it performs an ordinal comparison, however, it finds the substring only in the first string. Tenga en cuenta que en el caso de la primera cadena, que incluye el guión flexible seguido de una "m", el método no devuelve el índice del guion flexible sino que devuelve el índice de la "m" cuando realiza una comparación dependiente de la referencia cultural.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. El método devuelve el índice del guion virtual de la primera cadena solo cuando realiza una comparación ordinal.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) LastIndexOf(String, Int32) LastIndexOf(String, Int32) LastIndexOf(String, Int32)

Indica la posición de índice de base cero de la última aparición de una cadena especificada en la instancia en cuestión.Reports the zero-based index position of the last occurrence of a specified string within this instance. La búsqueda se inicia en una posición de carácter especificada y continúa hacia atrás hacia el principio de la cadena.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

Parámetros

value
String String String String

Cadena que se va a buscar.The string to seek.

startIndex
Int32 Int32 Int32 Int32

Posición en la que comienza la búsqueda.The search starting position. La búsqueda continúa desde startIndex hacia el principio de esta instancia.The search proceeds from startIndex toward the beginning of this instance.

Devoluciones

Posición del índice de inicio de base cero de value, si se encuentra esa cadena, o -1 si no se encuentra o si la instancia actual es igual que 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 es Empty, el valor devuelto es el menor de startIndex y la última posición de índice de esta instancia.If value is Empty, the return value is the smaller of startIndex and the last index position in this instance.

Excepciones

La instancia actual no es igual a Empty y startIndex es menor que cero o mayor que la longitud de la instancia actual.The current instance does not equal Empty, and startIndex is less than zero or greater than the length of the current instance.

O bien-or- La instancia actual es igual a Empty y startIndex es menor que -1 o mayor que cero.The current instance equals Empty, and startIndex is less than -1 or greater than zero.

Ejemplos

En el ejemplo siguiente se busca el índice de todas las apariciones de una cadena en la cadena de destino, desde el final de la cadena de destino hasta el inicio de la cadena de destino.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
'
'

Comentarios

La numeración de índices comienza en cero.Index numbering starts from zero. Es decir, el primer carácter de la cadena está en el índice cero y el último en Length -1.That is, the first character in the string is at index zero and the last is at Length - 1.

La búsqueda comienza en la startIndex posición de carácter de esta instancia y continúa hacia atrás hacia el principio value hasta que se encuentra o se examina la primera posición de carácter.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. Por ejemplo, si startIndex es Length -1, el método busca en cada carácter desde el último carácter de la cadena hasta el principio.For example, if startIndex is Length - 1, the method searches every character from the last character in the string to the beginning.

Este método realiza una búsqueda de palabras (con distinción de mayúsculas y minúsculas y con la referencia cultural) que usa la referencia cultural actual.This method performs a word (case-sensitive and culture-sensitive) search using the current culture.

Los juegos de caracteres incluyen caracteres que se pueden pasar por alto, que son los caracteres que no se tienen en cuenta al realizar una comparación lingüística o en la que se tiene en cuenta la referencia cultural.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. En una búsqueda que tiene en cuenta la referencia cultural, si value contiene un carácter que se puede pasar por alto, el resultado es equivalente a buscar sin ese carácter.In a culture-sensitive search, if value contains an ignorable character, the result is equivalent to searching with that character removed. Si value consta solo de uno o más caracteres que se pueden omitir, el startIndex LastIndexOf(String, Int32) método siempre devuelve, que es la posición del carácter en la que comienza la búsqueda.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. En el ejemplo siguiente, el LastIndexOf(String, Int32) método se usa para buscar una subcadena que incluya un guion blando (U + 00AD) y que preceda o incluya la "m" final en una cadena.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 el ejemplo se ejecuta en .NET Framework 4.NET Framework 4 o versiones posteriores, ya que se omite el guion flexible de la cadena de búsqueda, al llamar al método para buscar una subcadena formada por el guion blando y "m", se devuelve la posición de la "m" en la cadena, mientras que se llama a para buscar un substrin g formada por el guion blando y "n" devuelve la posición de la "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". Cuando la cadena de búsqueda contiene solo el guion flexible, el método devuelve el índice de la "m", que representa el valor startIndexde.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

Notas a los autores de las llamadas

Como se explica en procedimientos recomendados para el uso de cadenas, se recomienda evitar llamar a métodos de comparación de cadenas que sustituyan los valores predeterminados y, en su lugar, llamar a métodos que requieran que los parámetros se especifiquen explícitamente.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. Para buscar el índice de una subcadena que precede a una posición de carácter determinada usando las reglas de comparación de la referencia cultural actual LastIndexOf(String, Int32, StringComparison) , llame a la sobrecarga del CurrentCulture método con comparisonType un valor de para su parámetro.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.

Consulte también:

Se aplica a