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

Definição

Relata a posição de índice de base zero da última ocorrência de uma cadeia de caracteres ou um caractere Unicode especificado nesta instância.Reports the zero-based index position of the last occurrence of a specified Unicode character or string within this instance. O método retorna -1 caso o caractere ou a cadeia de caracteres não seja encontrado nessa instância.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)

Relata o índice com base em zero da última ocorrência de uma cadeia de caracteres especificada dentro do objeto String atual.Reports the zero-based index of the last occurrence of a specified string within the current String object. A pesquisa começa em uma posição de caractere especificada e continua até o início da cadeia de caracteres.The search starts at a specified character position and proceeds backward toward the beginning of the string. Um parâmetro especifica o tipo de comparação a ser realizada ao pesquisar a cadeia de caracteres 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)

Relata a posição de índice com base em zero da última ocorrência de uma cadeia de caracteres especificada nesta instância.Reports the zero-based index position of the last occurrence of a specified string within this instance. A pesquisa começa em uma posição de caractere especificada e continua para trás até o início da cadeia de caracteres de um número especificado de posições de caractere.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)

Relata a posição de índice que começa com zero da última ocorrência do caractere Unicode especificado em uma subcadeia de caracteres dentro dessa instância.Reports the zero-based index position of the last occurrence of the specified Unicode character in a substring within this instance. A pesquisa começa em uma posição de caractere especificada e continua para trás até o início da cadeia de caracteres de um número especificado de posições de caractere.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)

Relata o índice com base em zero da última ocorrência de uma cadeia de caracteres especificada dentro do objeto String atual.Reports the zero-based index of the last occurrence of a specified string within the current String object. Um parâmetro especifica o tipo de pesquisa a ser usado para a cadeia de caracteres especificada.A parameter specifies the type of search to use for the specified string.

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

Relata a posição de índice com base em zero da última ocorrência de um caractere Unicode especificado nesta instância.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)

Relata a posição de índice com base em zero da última ocorrência de um caractere Unicode especificado nesta instância.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance. A pesquisa começa em uma posição de caractere especificada e continua até o início da cadeia de caracteres.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)

Relata a posição de índice com base em zero da última ocorrência de uma cadeia de caracteres especificada nesta instância.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)

Relata a posição de índice com base em zero da última ocorrência de uma cadeia de caracteres especificada nesta instância.Reports the zero-based index position of the last occurrence of a specified string within this instance. A pesquisa começa em uma posição de caractere especificada e continua para trás até o início da cadeia de caracteres de um número especificado de posições de caractere.The search starts at a specified character position and proceeds backward toward the beginning of the string for the specified number of character positions. Um parâmetro especifica o tipo de comparação a ser realizada ao pesquisar a cadeia de caracteres 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)

Relata a posição de índice com base em zero da última ocorrência de uma cadeia de caracteres especificada nesta instância.Reports the zero-based index position of the last occurrence of a specified string within this instance. A pesquisa começa em uma posição de caractere especificada e continua até o início da cadeia de caracteres.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)

Relata o índice com base em zero da última ocorrência de uma cadeia de caracteres especificada dentro do objeto String atual.Reports the zero-based index of the last occurrence of a specified string within the current String object. A pesquisa começa em uma posição de caractere especificada e continua até o início da cadeia de caracteres.The search starts at a specified character position and proceeds backward toward the beginning of the string. Um parâmetro especifica o tipo de comparação a ser realizada ao pesquisar a cadeia de caracteres 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

A cadeia de caracteres a ser buscada.The string to seek.

startIndex
Int32 Int32 Int32 Int32

A posição inicial da pesquisa.The search starting position. A pesquisa continua de startIndex até o início dessa instância.The search proceeds from startIndex toward the beginning of this instance.

comparisonType
StringComparison StringComparison StringComparison StringComparison

Um dos valores de enumeração que especifica as regras para a pesquisa.One of the enumeration values that specifies the rules for the search.

Retornos

A posição do índice inicial baseado em zero do parâmetro value, se essa cadeia de caracteres for encontrada, ou -1, se ela não for encontrada ou se a instância atual for igual a 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. Se value for Empty, o valor retornado será o menor de startIndex e a última posição de índice nessa instância.If value is Empty, the return value is the smaller of startIndex and the last index position in this instance.

Exceções

A instância atual não é igual a Empty, e startIndex é menor que zero ou maior que o comprimento da instância atual.The current instance does not equal Empty, and startIndex is less than zero or greater than the length of the current instance.

- ou --or- A instância atual é igual a Empty, e startIndex é menor que -1 ou maior que zero.The current instance equals Empty, and startIndex is less than -1 or greater than zero.

comparisonType não é um valor StringComparison válido.comparisonType is not a valid StringComparison value.

Exemplos

O exemplo a seguir demonstra três sobrecargas do LastIndexOf método que localizam a última ocorrência de uma cadeia de caracteres dentro de outra cadeia de StringComparison caracteres usando valores diferentes da enumeração.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
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 'Main
End Class 'Sample

'
'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
'

Comentários

A numeração de índice começa do zero.Index numbering starts from zero. Ou seja, o primeiro caractere na cadeia de caracteres está no índice zero e o último está em Length - 1.That is, the first character in the string is at index zero and the last is at Length - 1.

A pesquisa começa na posição startIndex do caractere e prossegue para trás value até que seja encontrada ou a primeira posição do caractere seja examinada.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 exemplo, se startIndex for Length -1, o método pesquisará todos os caracteres do último caractere na cadeia de caracteres para o início.For example, if startIndex is Length - 1, the method searches every character from the last character in the string to the beginning.

O parâmetro comparisonType especifica a procura do parâmetro value usando a cultura atual ou invariável, usando uma pesquisa com ou sem diferenciação de maiúsculas e minúsculas e usando regras de comparação de palavra ou ordinais.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 aos Chamadores

Conjuntos de caracteres incluem caracteres ignoráveis, que são caracteres que não são considerados ao durante a realização de uma comparação linguística ou sensível à cultura.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. Em uma pesquisa sensível à cultura (ou seja, caso comparisonType não seja Ordinal ou OrdinalIgnoreCase), caso value contenha um caractere ignorável, o resultado é equivalente à pesquisa com esse caractere removido.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. Se value consistir apenas em um ou mais caracteres ignoráveis, LastIndexOf(String, Int32, StringComparison) o método sempre startIndexretornará, que é a posição do caractere na qual a pesquisa começa.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.

No exemplo a seguir, o LastIndexOf(String, Int32, StringComparison) método é usado para localizar a posição de um hífen flexível (U + 00AD) seguido por um "m", começando com o final "m" em duas cadeias de caracteres.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. Apenas uma das cadeias de caracteres contém a subcadeia de caracteres necessária.Only one of the strings contains the required substring. Se o exemplo for executado no .NET Framework 4.NET Framework 4 ou posterior, em ambos os casos, como o hífen suave é um caractere ignorável, o método retornará o índice de "m" na cadeia de caracteres quando ele executar uma comparação sensível à cultura.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. No caso da primeira cadeia de caracteres, que inclui o hífen condicional seguido de um "m", o método não retorna o índice do hífen virtual, mas retorna o índice do "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". O método só retorna o índice do hífen condicional na primeira cadeia de caracteres quando executa uma comparação 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)

Relata a posição de índice com base em zero da última ocorrência de uma cadeia de caracteres especificada nesta instância.Reports the zero-based index position of the last occurrence of a specified string within this instance. A pesquisa começa em uma posição de caractere especificada e continua para trás até o início da cadeia de caracteres de um número especificado de posições de caractere.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

A cadeia de caracteres a ser buscada.The string to seek.

startIndex
Int32 Int32 Int32 Int32

A posição inicial da pesquisa.The search starting position. A pesquisa continua de startIndex até o início dessa instância.The search proceeds from startIndex toward the beginning of this instance.

count
Int32 Int32 Int32 Int32

O número de posições de caractere a serem examinadas.The number of character positions to examine.

Retornos

A posição do índice inicial baseado em zero de value se essa cadeia de caracteres for encontrada ou -1 se ela não for encontrada ou se a instância atual for igual a 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. Se value for Empty, o valor retornado será o menor de startIndex e a última posição de índice nessa instância.If value is Empty, the return value is the smaller of startIndex and the last index position in this instance.

Exceções

count é negativo.count is negative.

- ou --or- A instância atual não é igual a Empty e startIndex é negativo.The current instance does not equal Empty, and startIndex is negative.

- ou --or- A instância atual não é igual a Empty e startIndex é maior que o tamanho dessa instância.The current instance does not equal Empty, and startIndex is greater than the length of this instance.

- ou --or- A instância atual não é igual a Empty e startIndex - count+ 1 especifica uma posição que não está dentro desta instância.The current instance does not equal Empty, and startIndex - count+ 1 specifies a position that is not within this instance.

- ou --or- A instância atual é igual a Empty e start é menor que -1 ou maior que zero.The current instance equals Empty and start is less than -1 or greater than zero.

- ou --or- A instância atual é igual a Empty e count é maior que 1.The current instance equals Empty and count is greater than 1.

Exemplos

O exemplo a seguir localiza o índice de todas as ocorrências de uma cadeia de caracteres na Subcadeia de caracteres, trabalhando a partir do final da subcadeia de caracteres até o início da subcadeia de caracteres.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)
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
      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 'Main 
End Class 'Sample
'
'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
'
'

Comentários

A numeração de índice começa do zero.Index numbering starts from zero. Ou seja, o primeiro caractere na cadeia de caracteres está no índice zero e o último está em Length - 1.That is, the first character in the string is at index zero and the last is at Length - 1.

A pesquisa começa na startIndex posição de caracteres dessa instância e volta para o início value até que seja encontrada ou que as posições count de caracteres tenham sido examinadas.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 exemplo, se startIndex for Length -1, o método pesquisará count caracteres regressivos do último caractere na cadeia de caracteres.For example, if startIndex is Length - 1, the method searches backward count characters from the last character in the string.

Este método executa uma pesquisa de palavra (diferencia maiúsculas de minúsculas e sensível à cultura) usando a cultura atual.This method performs a word (case-sensitive and culture-sensitive) search using the current culture.

Conjuntos de caracteres incluem caracteres ignoráveis, que são caracteres que não são considerados ao durante a realização de uma comparação linguística ou sensível à cultura.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. Em uma pesquisa sensível à cultura, caso value contenha um caractere ignorável, o resultado é equivalente à pesquisa com esse caractere removido.In a culture-sensitive search, if value contains an ignorable character, the result is equivalent to searching with that character removed. Se value consistir apenas em um ou mais caracteres ignoráveis, LastIndexOf o método sempre startIndexretornará, que é a posição do caractere na qual a pesquisa começa.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. No exemplo a seguir, o LastIndexOf método é usado para localizar a posição de um hífen flexível (U + 00AD) nos dois caracteres que precedem o "m" final de duas cadeias.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. Apenas uma das cadeias de caracteres contém a subcadeia de caracteres necessária.Only one of the strings contains the required substring. Se o exemplo for executado no .NET Framework 4.NET Framework 4 ou posterior, em ambos os casos, como o hífen suave é um caractere ignorável, o método retornará o índice de "m" na cadeia de caracteres quando ele executar uma comparação sensível à cultura.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. No caso da primeira cadeia de caracteres, que inclui o hífen condicional seguido de um "m", o método não retorna o índice do hífen virtual, mas retorna o índice do "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 aos Chamadores

Conforme explicado nas práticas recomendadas para usar cadeias decaracteres, é recomendável evitar a chamada de métodos de comparação de cadeia que substituem valores padrão e, em vez disso, chamam métodos que exigem que os parâmetros sejam especificados explicitamente.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 executar essa operação usando as regras de comparação da cultura atual, chame o LastIndexOf(String, Int32, Int32, StringComparison) método Overload com um valor de CurrentCulture para seu comparisonType 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.

Veja também

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

Relata a posição de índice que começa com zero da última ocorrência do caractere Unicode especificado em uma subcadeia de caracteres dentro dessa instância.Reports the zero-based index position of the last occurrence of the specified Unicode character in a substring within this instance. A pesquisa começa em uma posição de caractere especificada e continua para trás até o início da cadeia de caracteres de um número especificado de posições de caractere.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

O caractere Unicode a ser buscado.The Unicode character to seek.

startIndex
Int32 Int32 Int32 Int32

A posição inicial da pesquisa.The starting position of the search. A pesquisa continua de startIndex até o início dessa instância.The search proceeds from startIndex toward the beginning of this instance.

count
Int32 Int32 Int32 Int32

O número de posições de caractere a serem examinadas.The number of character positions to examine.

Retornos

A posição do índice baseado em zero de value se esse caractere for encontrado ou -1 se ele não for encontrado ou se a instância atual for igual a 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.

Exceções

A instância atual não é igual a Empty e startIndex é menor que zero ou maior ou igual ao tamanho dessa instância.The current instance does not equal Empty, and startIndex is less than zero or greater than or equal to the length of this instance.

- ou --or- A instância atual não é igual a Empty e startIndex - count + 1 é menor que zero.The current instance does not equal Empty, and startIndex - count + 1 is less than zero.

Exemplos

O exemplo a seguir localiza o índice de todas as ocorrências de um caractere em uma subcadeia de caracteres, trabalhando a partir do final da subcadeia de caracteres até o início da subcadeia de caracteres.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)
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
      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 'Main 
End Class 'Sample
'
'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
'
'

Comentários

A numeração de índice começa do zero.Index numbering starts from zero. Ou seja, o primeiro caractere na cadeia de caracteres está no índice zero e o último está em Length - 1.That is, the first character in the string is at index zero and the last is at Length - 1.

Esse método começa a Pesquisar na startIndex posição do caractere e prossegue para trás value até o início dessa instância até que seja encontrado ou count que as posições de caracteres tenham sido examinadas.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 exemplo, se startIndex for Length -1, o método pesquisará count caracteres regressivos do último caractere na cadeia de caracteres.For example, if startIndex is Length - 1, the method searches backward count characters from the last character in the string. A pesquisa diferencia maiúsculas de minúsculas.The search is case-sensitive.

Este método executa uma pesquisa ordinal (insensível à cultura), onde um caractere só é considerado equivalente a um outro caractere caso o valor escalar Unicode seja o mesmo.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 executar uma pesquisa sensível à cultura, use o método CompareInfo.LastIndexOf, em que um valor escalar Unicode representando um caractere pré-composto como a ligadura "Æ" (U+00C6) pode ser considerado equivalente a qualquer ocorrência dos componentes do caractere na sequência correta, como "AE" (U+0041, U+0045), dependendo da cultura.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.

Veja também

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

Relata o índice com base em zero da última ocorrência de uma cadeia de caracteres especificada dentro do objeto String atual.Reports the zero-based index of the last occurrence of a specified string within the current String object. Um parâmetro especifica o tipo de pesquisa a ser usado para a cadeia de caracteres 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

A cadeia de caracteres a ser buscada.The string to seek.

comparisonType
StringComparison StringComparison StringComparison StringComparison

Um dos valores de enumeração que especifica as regras para a pesquisa.One of the enumeration values that specifies the rules for the search.

Retornos

A posição do índice inicial com base em zero do parâmetro value se essa cadeia de caracteres for encontrada ou -1 caso não seja.The zero-based starting index position of the value parameter if that string is found, or -1 if it is not. Se value for Empty, o valor retornado será a última posição de índice nessa instância.If value is Empty, the return value is the last index position in this instance.

Exceções

comparisonType não é um valor StringComparison válido.comparisonType is not a valid StringComparison value.

Exemplos

O exemplo a seguir demonstra três sobrecargas do LastIndexOf método que localizam a última ocorrência de uma cadeia de caracteres dentro de outra cadeia de StringComparison caracteres usando valores diferentes da enumeração.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
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 'Main
End Class 'Sample

'
'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
'

Comentários

A numeração de índice começa do zero.Index numbering starts from zero. Ou seja, o primeiro caractere na cadeia de caracteres está no índice zero e o último está em Length - 1.That is, the first character in the string is at index zero and the last is at Length - 1.

O parâmetro comparisonType especifica a procura do parâmetro value usando a cultura atual ou invariável, usando uma pesquisa com ou sem diferenciação de maiúsculas e minúsculas e usando regras de comparação de palavra ou ordinais.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.

A pesquisa começa na última posição de caractere dessa instância e volta para o início até que value seja encontrada ou a primeira posição de caractere seja examinada.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 aos Chamadores

Conjuntos de caracteres incluem caracteres ignoráveis, que são caracteres que não são considerados ao durante a realização de uma comparação linguística ou sensível à cultura.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. Em uma pesquisa sensível à cultura (ou seja, caso options não seja Ordinal ou OrdinalIgnoreCase), caso value contenha um caractere ignorável, o resultado é equivalente à pesquisa com esse caractere removido.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. Se value consistir apenas em um ou mais caracteres ignoráveis, LastIndexOf(String, StringComparison) o método sempre Length retornará-1, que representa a última posição de índice na instância atual.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.

No exemplo a seguir, o LastIndexOf(String, StringComparison) método é usado para encontrar três subcadeias de caracteres (um hífen simples (U + 00AD), um hífen reversível seguido por "n" e um hífen, seguido por "m") em duas cadeias de caracteres.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. Apenas uma das cadeias de caracteres contém um hífen condicional.Only one of the strings contains a soft hyphen. Se o exemplo for executado no .NET Framework 4.NET Framework 4 ou posterior, como o hífen suave é um caractere ignorável, uma pesquisa sensível à cultura retorna o mesmo valor que ele retornaria se o hífen flexível não estivesse incluído na cadeia de caracteres de pesquisa.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. No entanto, uma pesquisa ordinal localiza com êxito o hífen suave em uma cadeia de caracteres e relata que ela está ausente da segunda cadeia de caracteres.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)

Relata a posição de índice com base em zero da última ocorrência de um caractere Unicode especificado nesta instância.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

O caractere Unicode a ser buscado.The Unicode character to seek.

Retornos

A posição do índice com base em zero de value caso o caractere seja encontrado -1 caso não seja.The zero-based index position of value if that character is found, or -1 if it is not.

Exemplos

O exemplo a seguir define ExtractFilename um método que usa LastIndexOf(Char) o método para localizar o último caractere separador de diretório em uma cadeia de caracteres e extrair o nome do arquivo da cadeia de caracteres.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. Se o arquivo existir, o método retornará o nome do arquivo sem seu caminho.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

Comentários

A numeração de índice começa do zero.Index numbering starts from zero. Ou seja, o primeiro caractere na cadeia de caracteres está no índice zero e o último está em Length - 1.That is, the first character in the string is at index zero and the last is at Length - 1.

Esse método começa a Pesquisar na última posição de caractere dessa instância e volta para o início até que value seja encontrado ou a primeira posição de caractere seja examinada.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. A pesquisa diferencia maiúsculas de minúsculas.The search is case-sensitive.

Este método executa uma pesquisa ordinal (insensível à cultura), onde um caractere só é considerado equivalente a um outro caractere caso os valores escalares Unicode sejam os mesmos.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 executar uma pesquisa sensível à cultura, use o método CompareInfo.LastIndexOf, em que um valor escalar Unicode representando um caractere pré-composto como a ligadura "Æ" (U+00C6) pode ser considerado equivalente a qualquer ocorrência dos componentes do caractere na sequência correta, como "AE" (U+0041, U+0045), dependendo da cultura.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.

Veja também

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

Relata a posição de índice com base em zero da última ocorrência de um caractere Unicode especificado nesta instância.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance. A pesquisa começa em uma posição de caractere especificada e continua até o início da cadeia de caracteres.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

O caractere Unicode a ser buscado.The Unicode character to seek.

startIndex
Int32 Int32 Int32 Int32

A posição inicial da pesquisa.The starting position of the search. A pesquisa continua de startIndex até o início dessa instância.The search proceeds from startIndex toward the beginning of this instance.

Retornos

A posição do índice baseado em zero de value se esse caractere for encontrado ou -1 se ele não for encontrado ou se a instância atual for igual a 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.

Exceções

A instância atual não é igual a Empty e startIndex é menor que zero ou maior ou igual ao tamanho dessa instância.The current instance does not equal Empty, and startIndex is less than zero or greater than or equal to the length of this instance.

Exemplos

O exemplo a seguir localiza o índice de todas as ocorrências de um caractere em uma cadeia de caracteres, trabalhando no final da cadeia de caracteres até o início da cadeia de caracteres.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 'Main
End Class 'Sample
'
'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
'

Comentários

A numeração de índice começa do zero.Index numbering starts from zero. Ou seja, o primeiro caractere na cadeia de caracteres está no índice zero e o último é Length em-1. esse método começa a Pesquisar startIndex na posição de caracteres dessa instância e prossegue para o início da instância atual até que seja value é encontrado ou a primeira posição de caractere foi examinada.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 exemplo, se startIndex for Length -1, o método pesquisará todos os caracteres do último caractere na cadeia de caracteres para o início.For example, if startIndex is Length - 1, the method searches every character from the last character in the string to the beginning. A pesquisa diferencia maiúsculas de minúsculas.The search is case-sensitive.

Este método executa uma pesquisa ordinal (insensível à cultura), onde um caractere só é considerado equivalente a um outro caractere caso os valores escalares Unicode sejam os mesmos.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 executar uma pesquisa sensível à cultura, use o método CompareInfo.LastIndexOf, em que um valor escalar Unicode representando um caractere pré-composto como a ligadura "Æ" (U+00C6) pode ser considerado equivalente a qualquer ocorrência dos componentes do caractere na sequência correta, como "AE" (U+0041, U+0045), dependendo da cultura.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.

Veja também

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

Relata a posição de índice com base em zero da última ocorrência de uma cadeia de caracteres especificada nesta instância.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

A cadeia de caracteres a ser buscada.The string to seek.

Retornos

A posição do índice inicial com base em zero de value, se a cadeia de caracteres for encontrada, ou -1, caso não seja.The zero-based starting index position of value if that string is found, or -1 if it is not. Se value for Empty, o valor retornado será a última posição de índice nessa instância.If value is Empty, the return value is the last index position in this instance.

Exceções

Exemplos

O exemplo a seguir remove as marcas HTML de abertura e fechamento de uma cadeia de caracteres se as marcas começam e terminam a cadeia de caracteres.The following example removes opening and closing HTML tags from a string if the tags begin and end the string. Se uma cadeia de caracteres terminar com um caractere de colchete de fechamento (">"), LastIndexOf o exemplo usará o método para localizar o início da marca de fim.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>

Comentários

A numeração de índice começa do zero.Index numbering starts from zero. Ou seja, o primeiro caractere na cadeia de caracteres está no índice zero e o último está em Length - 1.That is, the first character in the string is at index zero and the last is at Length - 1.

A pesquisa começa na última posição de caractere dessa instância e volta para o início até que value seja encontrada ou a primeira posição de caractere seja examinada.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 executa uma pesquisa de palavra (diferencia maiúsculas de minúsculas e sensível à cultura) usando a cultura atual.This method performs a word (case-sensitive and culture-sensitive) search using the current culture.

Conjuntos de caracteres incluem caracteres ignoráveis, que são caracteres que não são considerados ao durante a realização de uma comparação linguística ou sensível à cultura.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. Em uma pesquisa sensível à cultura, caso value contenha um caractere ignorável, o resultado é equivalente à pesquisa com esse caractere removido.In a culture-sensitive search, if value contains an ignorable character, the result is equivalent to searching with that character removed. Se value consistir apenas em um ou mais caracteres ignoráveis, LastIndexOf(String) o método sempre String.Length retornará-1, que representa a última posição de índice na instância atual.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. No exemplo a seguir, o LastIndexOf(String) método é usado para encontrar três subcadeias de caracteres (um hífen simples (U + 00AD), um hífen reversível seguido por "n" e um hífen, seguido por "m") em duas cadeias de caracteres.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. Apenas uma das cadeias de caracteres contém um hífen condicional.Only one of the strings contains a soft hyphen. Se o exemplo for executado no .NET Framework 4.NET Framework 4 ou posterior, em cada caso, como o hífen suave é um caractere ignorável, o resultado será o mesmo de se o hífen flexível não tivesse sido incluído no. 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. Ao pesquisar apenas um hífen suave, o método retorna 6 e 5.When searching for a soft hyphen only, the method returns 6 and 5. Esses valores correspondem ao índice do último caractere nas duas cadeias de caracteres.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 aos Chamadores

Conforme explicado nas práticas recomendadas para usar cadeias decaracteres, é recomendável evitar a chamada de métodos de comparação de cadeia que substituem valores padrão e, em vez disso, chamam métodos que exigem que os parâmetros sejam especificados explicitamente.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 localizar o último índice de uma subcadeia de caracteres em uma instância de cadeia de caracteres usando as regras de comparação da cultura LastIndexOf(String, StringComparison) atual, chame o método Overload CurrentCulture com um comparisonType valor de para seu 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.

Veja também

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

Relata a posição de índice com base em zero da última ocorrência de uma cadeia de caracteres especificada nesta instância.Reports the zero-based index position of the last occurrence of a specified string within this instance. A pesquisa começa em uma posição de caractere especificada e continua para trás até o início da cadeia de caracteres de um número especificado de posições de caractere.The search starts at a specified character position and proceeds backward toward the beginning of the string for the specified number of character positions. Um parâmetro especifica o tipo de comparação a ser realizada ao pesquisar a cadeia de caracteres 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

A cadeia de caracteres a ser buscada.The string to seek.

startIndex
Int32 Int32 Int32 Int32

A posição inicial da pesquisa.The search starting position. A pesquisa continua de startIndex até o início dessa instância.The search proceeds from startIndex toward the beginning of this instance.

count
Int32 Int32 Int32 Int32

O número de posições de caractere a serem examinadas.The number of character positions to examine.

comparisonType
StringComparison StringComparison StringComparison StringComparison

Um dos valores de enumeração que especifica as regras para a pesquisa.One of the enumeration values that specifies the rules for the search.

Retornos

A posição do índice inicial baseado em zero do parâmetro value, se essa cadeia de caracteres for encontrada, ou -1, se ela não for encontrada ou se a instância atual for igual a 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. Se value for Empty, o valor retornado será o menor de startIndex e a última posição de índice nessa instância.If value is Empty, the return value is the smaller of startIndex and the last index position in this instance.

Exceções

count é negativo.count is negative.

- ou --or- A instância atual não é igual a Empty e startIndex é negativo.The current instance does not equal Empty, and startIndex is negative.

- ou --or- A instância atual não é igual a Empty e startIndex é maior que o tamanho dessa instância.The current instance does not equal Empty, and startIndex is greater than the length of this instance.

- ou --or- A instância atual não é igual a Empty e startIndex + 1 - count especifica uma posição que não está dentro dessa instância.The current instance does not equal Empty, and startIndex + 1 - count specifies a position that is not within this instance.

- ou --or- A instância atual é igual a Empty e start é menor que -1 ou maior que zero.The current instance equals Empty and start is less than -1 or greater than zero.

- ou --or- A instância atual é igual a Empty e count é maior que 1.The current instance equals Empty and count is greater than 1.

comparisonType não é um valor StringComparison válido.comparisonType is not a valid StringComparison value.

Exemplos

O exemplo a seguir demonstra três sobrecargas do LastIndexOf método que localizam a última ocorrência de uma cadeia de caracteres dentro de outra cadeia de StringComparison caracteres usando valores diferentes da enumeração.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
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 'Main
End Class 'Sample

'
'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
'

Comentários

A numeração de índice começa do zero.Index numbering starts from zero. Ou seja, o primeiro caractere na cadeia de caracteres está no índice zero e o último está em Length - 1.That is, the first character in the string is at index zero and the last is at Length - 1.

A pesquisa começa na posição startIndex do caractere e prossegue para trás value até que seja encontrada ou count que as posições de caractere tenham sido examinadas.The search begins at the startIndex character position and proceeds backward until either value is found or count character positions have been examined. Por exemplo, se startIndex for Length -1, o método pesquisará count caracteres regressivos do último caractere na cadeia de caracteres.For example, if startIndex is Length - 1, the method searches backward count characters from the last character in the string.

O parâmetro comparisonType especifica a procura do parâmetro value usando a cultura atual ou invariável, usando uma pesquisa com ou sem diferenciação de maiúsculas e minúsculas e usando regras de comparação de palavra ou ordinais.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 aos Chamadores

Conjuntos de caracteres incluem caracteres ignoráveis, que são caracteres que não são considerados ao durante a realização de uma comparação linguística ou sensível à cultura.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. Em uma pesquisa sensível à cultura (ou seja, caso comparisonType não seja Ordinal ou OrdinalIgnoreCase), caso value contenha um caractere ignorável, o resultado é equivalente à pesquisa com esse caractere removido.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. Se value consistir apenas em um ou mais caracteres ignoráveis, LastIndexOf(String, Int32, Int32, StringComparison) o método sempre startIndexretornará, que é a posição do caractere na qual a pesquisa começa.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.

No exemplo a seguir, o LastIndexOf(String, Int32, Int32, StringComparison) método é usado para localizar a posição de um hífen flexível (U + 00AD) seguido por um "m" em todas, exceto a primeira posição de caractere antes do "m" final em duas cadeias de caracteres.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. Apenas uma das cadeias de caracteres contém a subcadeia de caracteres necessária.Only one of the strings contains the required substring. Se o exemplo for executado no .NET Framework 4.NET Framework 4 ou posterior, em ambos os casos, como o hífen suave é um caractere ignorável, o método retornará o índice de "m" na cadeia de caracteres quando ele executar uma comparação sensível à cultura.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. No entanto, quando ele executa uma comparação ordinal, ele encontra a subcadeia de caracteres somente na primeira cadeia de caracteres.When it performs an ordinal comparison, however, it finds the substring only in the first string. Observe que, no caso da primeira cadeia de caracteres, que inclui o hífen reversível seguido por um "m", o método não retorna o índice do hífen suave, mas, em vez disso, retorna o índice do "m" quando ele executa uma comparação sensível à cultura.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. O método só retorna o índice do hífen condicional na primeira cadeia de caracteres quando executa uma comparação 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)

Relata a posição de índice com base em zero da última ocorrência de uma cadeia de caracteres especificada nesta instância.Reports the zero-based index position of the last occurrence of a specified string within this instance. A pesquisa começa em uma posição de caractere especificada e continua até o início da cadeia de caracteres.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

A cadeia de caracteres a ser buscada.The string to seek.

startIndex
Int32 Int32 Int32 Int32

A posição inicial da pesquisa.The search starting position. A pesquisa continua de startIndex até o início dessa instância.The search proceeds from startIndex toward the beginning of this instance.

Retornos

A posição do índice inicial baseado em zero de value se essa cadeia de caracteres for encontrada ou -1 se ela não for encontrada ou se a instância atual for igual a 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. Se value for Empty, o valor retornado será o menor de startIndex e a última posição de índice nessa instância.If value is Empty, the return value is the smaller of startIndex and the last index position in this instance.

Exceções

A instância atual não é igual a Empty, e startIndex é menor que zero ou maior que o comprimento da instância atual.The current instance does not equal Empty, and startIndex is less than zero or greater than the length of the current instance.

- ou --or- A instância atual é igual a Empty, e startIndex é menor que -1 ou maior que zero.The current instance equals Empty, and startIndex is less than -1 or greater than zero.

Exemplos

O exemplo a seguir localiza o índice de todas as ocorrências de uma cadeia de caracteres na cadeia de caracteres de destino, trabalhando a partir do final da cadeia de caracteres de destino até o início da cadeia de caracteres 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)
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

      '#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 'Main 
End Class 'Sample
'
'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
'
'

Comentários

A numeração de índice começa do zero.Index numbering starts from zero. Ou seja, o primeiro caractere na cadeia de caracteres está no índice zero e o último está em Length - 1.That is, the first character in the string is at index zero and the last is at Length - 1.

A pesquisa começa na startIndex posição de caracteres dessa instância e volta para o início value até que seja encontrada ou a primeira posição de caractere seja examinada.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 exemplo, se startIndex for Length -1, o método pesquisará todos os caracteres do último caractere na cadeia de caracteres para o início.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 executa uma pesquisa de palavra (diferencia maiúsculas de minúsculas e sensível à cultura) usando a cultura atual.This method performs a word (case-sensitive and culture-sensitive) search using the current culture.

Conjuntos de caracteres incluem caracteres ignoráveis, que são caracteres que não são considerados ao durante a realização de uma comparação linguística ou sensível à cultura.Character sets include ignorable characters, which are characters that are not considered when performing a linguistic or culture-sensitive comparison. Em uma pesquisa sensível à cultura, caso value contenha um caractere ignorável, o resultado é equivalente à pesquisa com esse caractere removido.In a culture-sensitive search, if value contains an ignorable character, the result is equivalent to searching with that character removed. Se value consistir apenas em um ou mais caracteres ignoráveis, LastIndexOf(String, Int32) o método sempre startIndexretornará, que é a posição do caractere na qual a pesquisa começa.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. No exemplo a seguir, o LastIndexOf(String, Int32) método é usado para localizar uma subcadeia de caracteres que inclui um hífen flexível (U + 00AD) e que precede ou inclui o "m" final em uma cadeia de caracteres.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. Se o exemplo for executado no .NET Framework 4.NET Framework 4 ou posterior, porque o hífen flexível na cadeia de caracteres de pesquisa é ignorado, chamar o método para localizar uma subcadeia de caracteres que consiste no hífen suave e "m" retorna a posição do "m" na cadeia de caracteres, enquanto chama-o para encontrar um substrin g que consiste no hífen suave e "n" retorna a posição do "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". Quando a cadeia de caracteres de pesquisa contém apenas o hífen suave, o método retorna o índice do "m", que representa o startIndexvalor de.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 aos Chamadores

Conforme explicado nas práticas recomendadas para usar cadeias decaracteres, é recomendável evitar a chamada de métodos de comparação de cadeia que substituem valores padrão e, em vez disso, chamam métodos que exigem que os parâmetros sejam especificados explicitamente.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 localizar o índice de uma subcadeia de caracteres que precede uma posição de caractere específica usando as regras de comparação da cultura atual, chame LastIndexOf(String, Int32, StringComparison) o método Overload com um valor CurrentCulture de para comparisonType seu 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.

Veja também

Aplica-se a