String.LastIndexOf Método

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Informa de la posición de índice de base cero de la última aparición de un carácter o cadena Unicode especificado dentro de esta instancia. El método devuelve -1 si no se encuentra el carácter o la cadena en esta instancia.

Sobrecargas

LastIndexOf(String, Int32, Int32, StringComparison)	Informa de la posición de índice de base cero de la última aparición de una cadena especificada dentro de esta instancia. La búsqueda comienza en una posición de carácter especificada y continúa hacia atrás hacia el principio de la cadena para el número especificado de posiciones de caracteres. Un parámetro especifica el tipo de comparación que se va a realizar al buscar la cadena especificada.
LastIndexOf(String, Int32, Int32)	Informa de la posición de índice de base cero de la última aparición de una cadena especificada dentro de esta instancia. La búsqueda comienza en una posición de carácter especificada y continúa hacia atrás hacia el principio de la cadena para un número especificado de posiciones de caracteres.
LastIndexOf(Char, Int32, Int32)	Informa de la posición de índice de base cero de la última aparición del carácter Unicode especificado en una subcadena dentro de esta instancia. La búsqueda comienza en una posición de carácter especificada y continúa hacia atrás hacia el principio de la cadena para un número especificado de posiciones de caracteres.
LastIndexOf(String, StringComparison)	Informa del índice de base cero de la última aparición de una cadena especificada dentro del objeto String actual. Un parámetro especifica el tipo de búsqueda que se va a usar para la cadena especificada.
LastIndexOf(String, Int32, StringComparison)	Informa del índice de base cero de la última aparición de una cadena especificada dentro del objeto String actual. La búsqueda comienza en una posición de carácter especificada y continúa hacia atrás hacia el principio de la cadena. Un parámetro especifica el tipo de comparación que se va a realizar al buscar la cadena especificada.
LastIndexOf(Char, Int32)	Informa de la posición de índice de base cero de la última aparición de un carácter Unicode especificado dentro de esta instancia. La búsqueda comienza en una posición de carácter especificada y continúa hacia atrás hacia el principio de la cadena.
LastIndexOf(String)	Informa de la posición de índice de base cero de la última aparición de una cadena especificada dentro de esta instancia.
LastIndexOf(Char)	Informa de la posición de índice de base cero de la última aparición de un carácter Unicode especificado dentro de esta instancia.
LastIndexOf(String, Int32)	Informa de la posición de índice de base cero de la última aparición de una cadena especificada dentro de esta instancia. La búsqueda comienza en una posición de carácter especificada y continúa hacia atrás hacia el principio de la cadena.

LastIndexOf(String, Int32, Int32, StringComparison)

Source:

String.Searching.cs

Informa de la posición de índice de base cero de la última aparición de una cadena especificada dentro de esta instancia. La búsqueda comienza en una posición de carácter especificada y continúa hacia atrás hacia el principio de la cadena para el número especificado de posiciones de caracteres. Un parámetro especifica el tipo de comparación que se va a realizar al buscar la cadena especificada.

C#

public int LastIndexOf (string value, int startIndex, int count, StringComparison comparisonType);

Parámetros

value

String

Cadena que se va a buscar.

startIndex

Int32

Posición inicial de búsqueda. La búsqueda continúa desde startIndex hacia el principio de esta instancia.

count

Int32

Número de posiciones de caracteres que se van a examinar.

comparisonType

StringComparison

Uno de los valores de enumeración que especifica las reglas de la búsqueda.

Devoluciones

Int32

Posición de índice inicial de base cero del parámetro value si se encuentra esa cadena o -1 si no se encuentra o si la instancia actual es igual a Empty.

Excepciones

ArgumentNullException

value es null.

ArgumentOutOfRangeException

count es negativo.

-o-

La instancia actual no es igual a Emptyy startIndex es negativa.

-o-

La instancia actual no es igual a Emptyy startIndex es mayor que la longitud de esta instancia.

-o-

La instancia actual no es igual a Emptyy startIndex + 1 count especifica una posición que no está dentro de esta instancia.

-o-

La instancia actual es igual a Empty y startIndex es menor que -1 o mayor que cero.

-o-

La instancia actual es igual a Empty y count es mayor que 1.

ArgumentException

comparisonType no es un valor de StringComparison válido.

Ejemplos

En el ejemplo siguiente se muestran tres sobrecargas del método LastIndexOf que encuentran la última aparición de una cadena dentro de otra cadena mediante valores diferentes de la enumeración StringComparison.

C#

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

*/

Comentarios

La numeración de índice comienza desde cero. Es decir, el primer carácter de la cadena está en el índice cero y el último está en Length - 1.

La búsqueda comienza en la posición del carácter startIndex y continúa hacia atrás hasta que se encuentra value o count se han examinado las posiciones de caracteres. Por ejemplo, si startIndex es Length - 1, el método busca count caracteres hacia atrás del último carácter de la cadena.

El parámetro comparisonType especifica que se va a buscar el parámetro value mediante:

• Referencia cultural actual o invariable.
• Búsqueda sin distinción entre mayúsculas y minúsculas o sin distinción entre mayúsculas y minúsculas.
• Reglas de comparación ordinal de Word.

Notas a los autores de las llamadas

Los juegos de caracteres incluyen caracteres ignorables, que son caracteres que no se tienen en cuenta al realizar una comparación lingüística o sensible a la referencia cultural. En una búsqueda que distingue referencias culturales (es decir, si comparisonType no es Ordinal o OrdinalIgnoreCase), si value contiene un carácter ignorable, el resultado es equivalente a buscar con ese carácter quitado.

En el ejemplo siguiente, el método LastIndexOf(String, Int32, Int32, StringComparison) se usa para buscar la posición de un guión suave (U+00AD) seguido de un "m" en todo, pero la primera posición del carácter antes de la "m" final en dos cadenas. Solo una de las cadenas contiene la subcadena necesaria. Si el ejemplo se ejecuta en .NET Framework 4 o posterior, en ambos casos, porque el guión temporal es un carácter ignorable, el método devuelve el índice de "m" en la cadena cuando realiza una comparación que distingue la referencia cultural. Sin embargo, cuando realiza una comparación ordinal, solo encuentra la subcadena en la primera cadena. Tenga en cuenta que, en el caso de la primera cadena, que incluye el guión temporal seguido de "m", el método devuelve el índice de "m" cuando realiza una comparación que distingue la referencia cultural. El método devuelve el índice del guión temporal de la primera cadena solo cuando realiza una comparación ordinal.

C#

string searchString = "\u00ADm";

string s1 = "ani\u00ADmal";
string s2 = "animal";

int position;

position = s1.LastIndexOf('m');
if (position >= 1)
{
    Console.WriteLine(s1.LastIndexOf(searchString, position, position, StringComparison.CurrentCulture));
    Console.WriteLine(s1.LastIndexOf(searchString, position, position, StringComparison.Ordinal));
}

position = s2.LastIndexOf('m');
if (position >= 1)
{
    Console.WriteLine(s2.LastIndexOf(searchString, position, position, StringComparison.CurrentCulture));
    Console.WriteLine(s2.LastIndexOf(searchString, position, position, StringComparison.Ordinal));
}

// The example displays the following output:
//
// 4
// 3
// 3
// -1

LastIndexOf(String, Int32, Int32)

Source:

String.Searching.cs

Informa de la posición de índice de base cero de la última aparición de una cadena especificada dentro de esta instancia. La búsqueda comienza en una posición de carácter especificada y continúa hacia atrás hacia el principio de la cadena para un número especificado de posiciones de caracteres.

C#

public int LastIndexOf (string value, int startIndex, int count);

Parámetros

value

String

Cadena que se va a buscar.

startIndex

Int32

Posición inicial de búsqueda. La búsqueda continúa desde startIndex hacia el principio de esta instancia.

count

Int32

Número de posiciones de caracteres que se van a examinar.

Devoluciones

Int32

Posición de índice inicial de base cero de value si se encuentra esa cadena o -1 si no se encuentra o si la instancia actual es igual a Empty.

Excepciones

ArgumentNullException

value es null.

ArgumentOutOfRangeException

count es negativo.

-o-

La instancia actual no es igual a Emptyy startIndex es negativa.

-o-

La instancia actual no es igual a Emptyy startIndex es mayor que la longitud de esta instancia.

-o-

La instancia actual no es igual a Emptyy startIndex - count+ 1 especifica una posición que no está dentro de esta instancia.

-o-

La instancia actual es igual a Empty y startIndex es menor que -1 o mayor que cero.

-o-

La instancia actual es igual a Empty y count es mayor que 1.

Ejemplos

En el ejemplo siguiente se busca el índice de todas las apariciones de una cadena en la subcadena, trabajando desde el final de la subcadena hasta el inicio de la subcadena.

C#

// 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
*/

Comentarios

La numeración de índice comienza desde cero. Es decir, el primer carácter de la cadena está en el índice cero y el último está en Length - 1.

La búsqueda comienza en la posición del carácter startIndex de esta instancia y continúa hacia atrás hacia el principio hasta que se encuentra value o se han examinado count posiciones de caracteres. Por ejemplo, si startIndex es Length - 1, el método busca count caracteres hacia atrás del último carácter de la cadena.

Este método realiza una búsqueda de palabras (con distinción entre mayúsculas y minúsculas y con distinción de referencia cultural) mediante la referencia cultural actual.

Los juegos de caracteres incluyen caracteres ignorables, que son caracteres que no se tienen en cuenta al realizar una comparación lingüística o sensible a la referencia cultural. En una búsqueda que distingue la referencia cultural, si value contiene un carácter ignorable, el resultado es equivalente a buscar con ese carácter quitado.

En el ejemplo siguiente, el método LastIndexOf se usa para buscar la posición de un guión suave (U+00AD) seguido de "m" o "n" en dos cadenas. Solo una de las cadenas contiene un guión flexible. En el caso de la cadena que incluye el guión suave seguido de "m", LastIndexOf devuelve el índice de "m" al buscar el guión suave seguido de "m".

C#

int position = 0;
string s1 = "ani\u00ADmal";
string s2 = "animal";

// Find the index of the soft hyphen followed by "n".
position = s1.LastIndexOf("m");
Console.WriteLine($"'m' at position {position}");

if (position >= 0)
    Console.WriteLine(s1.LastIndexOf("\u00ADn", position, position + 1));

position = s2.LastIndexOf("m");
Console.WriteLine($"'m' at position {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 {position}");

if (position >= 0)
    Console.WriteLine(s1.LastIndexOf("\u00ADm", position, position + 1));

position = s2.LastIndexOf("m");
Console.WriteLine($"'m' at position {position}");

if (position >= 0)
    Console.WriteLine(s2.LastIndexOf("\u00ADm", position, position + 1));

// The example displays the following output:
//
// 'm' at position 4
// 1
// 'm' at position 3
// 1
// 'm' at position 4
// 4
// 'm' at position 3
// 3

Notas a los autores de las llamadas

Como se explica en Procedimientos recomendados para usar cadenas, se recomienda evitar llamar a métodos de comparación de cadenas que sustituya los valores predeterminados y, en su lugar, llame a métodos que requieren que se especifiquen explícitamente los parámetros. Para realizar esta operación mediante las reglas de comparación de la referencia cultural actual, indique su intención explícitamente llamando a la sobrecarga del método LastIndexOf(String, Int32, Int32, StringComparison) con un valor de CurrentCulture para su parámetro comparisonType. Si no necesita una comparación con reconocimiento lingüístico, considere la posibilidad de usar Ordinal.

Consulte también

• Int32
• IndexOf(Char)
• IndexOfAny(Char[])
• LastIndexOfAny(Char[])

LastIndexOf(Char, Int32, Int32)

Source:

String.Searching.cs

Informa de la posición de índice de base cero de la última aparición del carácter Unicode especificado en una subcadena dentro de esta instancia. La búsqueda comienza en una posición de carácter especificada y continúa hacia atrás hacia el principio de la cadena para un número especificado de posiciones de caracteres.

C#

public int LastIndexOf (char value, int startIndex, int count);

Parámetros

value

Char

Carácter Unicode que se va a buscar.

startIndex

Int32

Posición inicial de la búsqueda. La búsqueda continúa desde startIndex hacia el principio de esta instancia.

count

Int32

Número de posiciones de caracteres que se van a examinar.

Devoluciones

Int32

Posición de índice de base cero de value si se encuentra ese carácter o -1 si no se encuentra o si la instancia actual es igual a Empty.

Excepciones

ArgumentOutOfRangeException

La instancia actual no es igual a Emptyy startIndex es menor que cero o mayor o igual que la longitud de esta instancia.

-o-

La instancia actual no es igual a Emptyy startIndex - count + 1 es menor que cero.

Ejemplos

En el ejemplo siguiente se busca el índice de todas las apariciones de un carácter en una subcadena, trabajando desde el final de la subcadena hasta el inicio de la subcadena.

C#

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


*/

Comentarios

La numeración de índice comienza desde cero. Es decir, el primer carácter de la cadena está en el índice cero y el último está en Length - 1.

Este método comienza a buscar en la posición del carácter startIndex y continúa hacia atrás hacia el principio de esta instancia hasta que se encuentre value o se hayan examinado count posiciones de caracteres. Por ejemplo, si startIndex es Length - 1, el método busca count caracteres hacia atrás del último carácter de la cadena. La búsqueda distingue mayúsculas de minúsculas.

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

Consulte también

• Char
• Int32
• IndexOf(Char)
• IndexOfAny(Char[])
• LastIndexOfAny(Char[])

LastIndexOf(String, StringComparison)

Source:

String.Searching.cs

Informa del índice de base cero de la última aparición de una cadena especificada dentro del objeto String actual. Un parámetro especifica el tipo de búsqueda que se va a usar para la cadena especificada.

C#

public int LastIndexOf (string value, StringComparison comparisonType);

Parámetros

value

String

Cadena que se va a buscar.

comparisonType

StringComparison

Uno de los valores de enumeración que especifica las reglas de la búsqueda.

Devoluciones

Int32

Posición de índice inicial de base cero del parámetro value si se encuentra esa cadena o -1 si no lo es.

Excepciones

ArgumentNullException

value es null.

ArgumentException

comparisonType no es un valor de StringComparison válido.

Ejemplos

En el ejemplo siguiente se muestran tres sobrecargas del método LastIndexOf que encuentran la última aparición de una cadena dentro de otra cadena mediante valores diferentes de la enumeración StringComparison.

C#

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

*/

Comentarios

La numeración de índice comienza desde cero. Es decir, el primer carácter de la cadena está en el índice cero y el último está en Length - 1.

El parámetro comparisonType especifica que se va a buscar el parámetro value mediante:

• Referencia cultural actual o invariable.
• Búsqueda sin distinción entre mayúsculas y minúsculas o sin distinción entre mayúsculas y minúsculas.
• Reglas de comparación ordinal de Word.

La búsqueda comienza en la última posición del carácter de esta instancia y continúa hacia atrás hacia el principio hasta que se encuentra value o se ha examinado la primera posición del carácter.

Notas a los autores de las llamadas

Los juegos de caracteres incluyen caracteres ignorables, que son caracteres que no se tienen en cuenta al realizar una comparación lingüística o sensible a la referencia cultural. En una búsqueda que distingue referencias culturales (es decir, si options no es Ordinal o OrdinalIgnoreCase), si value contiene un carácter ignorable, el resultado es equivalente a buscar con ese carácter quitado.

En el ejemplo siguiente, el método LastIndexOf(String, StringComparison) se usa para buscar dos subcadenas (un guión suave seguido de "n" y un guión suave seguido de "m") en dos cadenas. Solo una de las cadenas contiene un guión flexible. Si el ejemplo se ejecuta en .NET Framework 4 o posterior, porque el guión temporal es un carácter ignorable, una búsqueda que distingue la referencia cultural devuelve el mismo valor que devolvería si el guión temporal no se incluyera en la cadena de búsqueda. Sin embargo, una búsqueda ordinal encuentra correctamente el guión temporal en una cadena e informa de que está ausente de la segunda cadena.

C#

string s1 = "ani\u00ADmal";
string s2 = "animal";

Console.WriteLine("Culture-sensitive comparison:");

// Use culture-sensitive comparison to find the last soft hyphen followed by "n".
Console.WriteLine(s1.LastIndexOf("\u00ADn", StringComparison.CurrentCulture));
Console.WriteLine(s2.LastIndexOf("\u00ADn", StringComparison.CurrentCulture));

// Use culture-sensitive comparison to find the last soft hyphen followed by "m".
Console.WriteLine(s1.LastIndexOf("\u00ADm", StringComparison.CurrentCulture));
Console.WriteLine(s2.LastIndexOf("\u00ADm", StringComparison.CurrentCulture));

Console.WriteLine("Ordinal comparison:");

// Use ordinal comparison to find the last soft hyphen followed by "n".
Console.WriteLine(s1.LastIndexOf("\u00ADn", StringComparison.Ordinal));
Console.WriteLine(s2.LastIndexOf("\u00ADn", StringComparison.Ordinal));

// Use ordinal comparison to find the last soft hyphen followed by "m".
Console.WriteLine(s1.LastIndexOf("\u00ADm", StringComparison.Ordinal));
Console.WriteLine(s2.LastIndexOf("\u00ADm", StringComparison.Ordinal));

// The example displays the following output:
//
// Culture-sensitive comparison:
// 1
// 1
// 4
// 3
// Ordinal comparison:
// -1
// -1
// 3
// -1

LastIndexOf(String, Int32, StringComparison)

Source:

String.Searching.cs

Informa del índice de base cero de la última aparición de una cadena especificada dentro del objeto String actual. La búsqueda comienza en una posición de carácter especificada y continúa hacia atrás hacia el principio de la cadena. Un parámetro especifica el tipo de comparación que se va a realizar al buscar la cadena especificada.

C#

public int LastIndexOf (string value, int startIndex, StringComparison comparisonType);

Parámetros

value

String

Cadena que se va a buscar.

startIndex

Int32

Posición inicial de búsqueda. La búsqueda continúa desde startIndex hacia el principio de esta instancia.

comparisonType

StringComparison

Uno de los valores de enumeración que especifica las reglas de la búsqueda.

Devoluciones

Int32

Posición de índice inicial de base cero del parámetro value si se encuentra esa cadena o -1 si no se encuentra o si la instancia actual es igual a Empty.

Excepciones

ArgumentNullException

value es null.

ArgumentOutOfRangeException

La instancia actual no es igual a Emptyy startIndex es menor que cero o mayor que la longitud de la instancia actual.

-o-

La instancia actual es igual a Emptyy startIndex es menor que -1 o mayor que cero.

ArgumentException

comparisonType no es un valor de StringComparison válido.

Ejemplos

En el ejemplo siguiente se muestran tres sobrecargas del método LastIndexOf que encuentran la última aparición de una cadena dentro de otra cadena mediante valores diferentes de la enumeración StringComparison.

C#

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

*/

Comentarios

La numeración de índice comienza desde cero. Es decir, el primer carácter de la cadena está en el índice cero y el último está en Length - 1.

La búsqueda comienza en la posición del carácter startIndex y continúa hacia atrás hasta que se encuentra value o se ha examinado la primera posición del carácter. Por ejemplo, si startIndex es Length - 1, el método busca cada carácter desde el último carácter de la cadena hasta el principio.

El parámetro comparisonType especifica buscar el parámetro value mediante la referencia cultural actual o invariable, mediante una búsqueda sin distinción entre mayúsculas y minúsculas o con reglas de comparación ordinal de palabras.

Notas a los autores de las llamadas

Los juegos de caracteres incluyen caracteres ignorables, que son caracteres que no se tienen en cuenta al realizar una comparación lingüística o sensible a la referencia cultural. En una búsqueda que distingue referencias culturales (es decir, si comparisonType no es Ordinal o OrdinalIgnoreCase), si value contiene un carácter ignorable, el resultado es equivalente a buscar con ese carácter quitado.

En el ejemplo siguiente, el método LastIndexOf(String, Int32, StringComparison) se usa para buscar la posición de un guión suave (U+00AD) seguido de un "m", empezando por el "m" final en dos cadenas. Solo una de las cadenas contiene la subcadena necesaria. Si el ejemplo se ejecuta en .NET Framework 4 o posterior, en ambos casos, porque el guión temporal es un carácter ignorable, el método devuelve el índice de "m" en la cadena cuando realiza una comparación que distingue la referencia cultural. Tenga en cuenta que, en el caso de la primera cadena, que incluye el guión suave seguido de "m", el método devuelve el índice de "m" y no el índice del guion suave. El método devuelve el índice del guión temporal de la primera cadena solo cuando realiza una comparación ordinal.

C#

string searchString = "\u00ADm";

string s1 = "ani\u00ADmal";
string s2 = "animal";

int position;

position = s1.LastIndexOf('m');
if (position >= 0)
{
    Console.WriteLine(s1.LastIndexOf(searchString, position, StringComparison.CurrentCulture));
    Console.WriteLine(s1.LastIndexOf(searchString, position, StringComparison.Ordinal));
}

position = s2.LastIndexOf('m');
if (position >= 0)
{
    Console.WriteLine(s2.LastIndexOf(searchString, position, StringComparison.CurrentCulture));
    Console.WriteLine(s2.LastIndexOf(searchString, position, StringComparison.Ordinal));
}

// The example displays the following output:
//
// 4
// 3
// 3
// -1

LastIndexOf(Char, Int32)

Source:

String.Searching.cs

Informa de la posición de índice de base cero de la última aparición de un carácter Unicode especificado dentro de esta instancia. La búsqueda comienza en una posición de carácter especificada y continúa hacia atrás hacia el principio de la cadena.

C#

public int LastIndexOf (char value, int startIndex);

Parámetros

value

Char

Carácter Unicode que se va a buscar.

startIndex

Int32

Posición inicial de la búsqueda. La búsqueda continúa desde startIndex hacia el principio de esta instancia.

Devoluciones

Int32

Posición de índice de base cero de value si se encuentra ese carácter o -1 si no se encuentra o si la instancia actual es igual a Empty.

Excepciones

ArgumentOutOfRangeException

La instancia actual no es igual a Emptyy startIndex es menor que cero o mayor o igual que la longitud de esta instancia.

Ejemplos

En el ejemplo siguiente se busca el índice de todas las apariciones de un carácter en una cadena, trabajando desde el final de la cadena hasta el inicio de la cadena.

C#

// 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
*/

Comentarios

La numeración de índice comienza desde cero. Es decir, el primer carácter de la cadena está en el índice cero y el último está en Length - 1. Este método comienza a buscar en la posición del carácter startIndex de esta instancia y continúa hacia atrás hacia el principio de la instancia actual hasta que se encuentre value o se haya examinado la primera posición del carácter. Por ejemplo, si startIndex es Length - 1, el método busca cada carácter desde el último carácter de la cadena hasta el principio. La búsqueda distingue mayúsculas de minúsculas.

Este método realiza una búsqueda ordinal (que no distingue la referencia cultural), donde un carácter se considera equivalente a otro carácter solo si sus valores escalares Unicode son los mismos. Para realizar una búsqueda que tenga en cuenta la referencia cultural, use el método CompareInfo.LastIndexOf, donde un valor escalar Unicode que representa un carácter precomponido, como la ligadura "Æ" (U+00C6), podría considerarse equivalente a cualquier aparición de los componentes del carácter en la secuencia correcta, como "AE" (U+0041, U+0045), dependiendo de la referencia cultural.

Consulte también

• Char
• Int32
• IndexOf(Char)
• IndexOfAny(Char[])
• LastIndexOfAny(Char[])

LastIndexOf(String)

Source:

String.Searching.cs

Informa de la posición de índice de base cero de la última aparición de una cadena especificada dentro de esta instancia.

C#

public int LastIndexOf (string value);

Parámetros

value

String

Cadena que se va a buscar.

Devoluciones

Int32

Posición de índice inicial de base cero de value si se encuentra esa cadena o -1 si no lo está.

Excepciones

ArgumentNullException

value es null.

Ejemplos

En el ejemplo siguiente se quitan las etiquetas HTML de apertura y cierre de una cadena si las etiquetas comienzan y terminan la cadena. Si una cadena termina con un carácter de corchete de cierre (">"), el ejemplo usa el método LastIndexOf para buscar el inicio de la etiqueta final.

C#

using System;

public class Example 
{
   public static void Main() 
   {
      string[] strSource = { "<b>This is bold text</b>", "<H1>This is large Text</H1>",
               "<b><i><font color=green>This has multiple tags</font></i></b>",
               "<b>This has <i>embedded</i> tags.</b>",
               "This line 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>

Comentarios

La numeración de índice comienza desde cero. Es decir, el primer carácter de la cadena está en el índice cero y el último está en Length - 1.

La búsqueda comienza en la última posición del carácter de esta instancia y continúa hacia atrás hacia el principio hasta que se encuentra value o se ha examinado la primera posición del carácter.

Este método realiza una búsqueda de palabras (con distinción entre mayúsculas y minúsculas y con distinción de referencia cultural) mediante la referencia cultural actual.

Los juegos de caracteres incluyen caracteres ignorables, que son caracteres que no se tienen en cuenta al realizar una comparación lingüística o sensible a la referencia cultural. En una búsqueda que distingue la referencia cultural, si value contiene un carácter ignorable, el resultado es equivalente a buscar con ese carácter quitado.

En el ejemplo siguiente, el método LastIndexOf(String) se usa para buscar dos subcadenas (un guión suave seguido de "n" y un guión suave seguido de "m") en dos cadenas. Solo una de las cadenas contiene un guión flexible. Si el ejemplo se ejecuta en .NET Framework 4 o posterior, en cada caso, porque el guión suave es un carácter ignorable, el resultado es el mismo que si el guión suave no se hubiera incluido en value.

C#

string s1 = "ani\u00ADmal";
string s2 = "animal";

// 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:
//
// 1
// 1
// 4
// 3

Notas a los autores de las llamadas

Como se explica en Procedimientos recomendados para usar cadenas, se recomienda evitar llamar a métodos de comparación de cadenas que sustituya los valores predeterminados y, en su lugar, llame a métodos que requieren que se especifiquen explícitamente los parámetros. Para buscar el último índice de una subcadena dentro de una instancia de cadena mediante las reglas de comparación de la referencia cultural actual, indique su intención explícitamente llamando a la sobrecarga del método LastIndexOf(String, StringComparison) con un valor de CurrentCulture para su parámetro comparisonType. Si no necesita una comparación con reconocimiento lingüístico, considere la posibilidad de usar Ordinal.

Consulte también

• Int32
• IndexOf(Char)
• IndexOfAny(Char[])
• LastIndexOfAny(Char[])

LastIndexOf(Char)

Source:

String.Searching.cs

Informa de la posición de índice de base cero de la última aparición de un carácter Unicode especificado dentro de esta instancia.

C#

public int LastIndexOf (char value);

Parámetros

value

Char

Carácter Unicode que se va a buscar.

Devoluciones

Int32

Posición de índice de base cero de value si se encuentra ese carácter o -1 si no lo es.

Ejemplos

En el ejemplo siguiente se define un método ExtractFilename que usa el método LastIndexOf(Char) para buscar el último carácter separador de directorio en una cadena y extraer el nombre de archivo de la cadena. Si el archivo existe, el método devuelve el nombre de archivo sin su ruta de acceso.

C#

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;
      }
   }
}

Comentarios

La numeración de índice comienza desde cero. Es decir, el primer carácter de la cadena está en el índice cero y el último está en Length - 1.

Este método comienza a buscar en la última posición de carácter de esta instancia y continúa hacia atrás hacia el principio hasta que se encuentra value o se ha examinado la primera posición del carácter. La búsqueda distingue mayúsculas de minúsculas.

Este método realiza una búsqueda ordinal (que no distingue la referencia cultural), donde un carácter se considera equivalente a otro carácter solo si sus valores escalares Unicode son los mismos. Para realizar una búsqueda que tenga en cuenta la referencia cultural, use el método CompareInfo.LastIndexOf, donde un valor escalar Unicode que representa un carácter precomponido, como la ligadura "Æ" (U+00C6), podría considerarse equivalente a cualquier aparición de los componentes del carácter en la secuencia correcta, como "AE" (U+0041, U+0045), dependiendo de la referencia cultural.

Consulte también

• Char
• IndexOf(Char)
• IndexOfAny(Char[])
• LastIndexOfAny(Char[])

LastIndexOf(String, Int32)

Source:

String.Searching.cs

Informa de la posición de índice de base cero de la última aparición de una cadena especificada dentro de esta instancia. La búsqueda comienza en una posición de carácter especificada y continúa hacia atrás hacia el principio de la cadena.

C#

public int LastIndexOf (string value, int startIndex);

Parámetros

value

String

Cadena que se va a buscar.

startIndex

Int32

Posición inicial de búsqueda. La búsqueda continúa desde startIndex hacia el principio de esta instancia.

Devoluciones

Int32

Posición de índice inicial de base cero de value si se encuentra esa cadena o -1 si no se encuentra o si la instancia actual es igual a Empty.

Excepciones

ArgumentNullException

value es null.

ArgumentOutOfRangeException

La instancia actual no es igual a Emptyy startIndex es menor que cero o mayor que la longitud de la instancia actual.

-o-

La instancia actual es igual a Emptyy startIndex es menor que -1 o mayor que cero.

Ejemplos

En el ejemplo siguiente se busca el índice de todas las apariciones de una cadena en la cadena de destino, trabajando desde el final de la cadena de destino hasta el inicio de la cadena de destino.

C#

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


*/

Comentarios

La numeración de índice comienza desde cero. Es decir, el primer carácter de la cadena está en el índice cero y el último está en Length - 1.

La búsqueda comienza en la posición del carácter startIndex de esta instancia y continúa hacia atrás hacia el principio hasta que se encuentra value o se ha examinado la primera posición del carácter. Por ejemplo, si startIndex es Length - 1, el método busca cada carácter desde el último carácter de la cadena hasta el principio.

Este método realiza una búsqueda de palabras (con distinción entre mayúsculas y minúsculas y con distinción de referencia cultural) mediante la referencia cultural actual.

Los juegos de caracteres incluyen caracteres ignorables, que son caracteres que no se tienen en cuenta al realizar una comparación lingüística o sensible a la referencia cultural. En una búsqueda que distingue la referencia cultural, si value contiene un carácter ignorable, el resultado es equivalente a buscar con ese carácter quitado. En el ejemplo siguiente, el método LastIndexOf(String, Int32) se usa para buscar una subcadena que incluya un guión suave (U+00AD) y que precede o incluye el "m" final en una cadena. Si el ejemplo se ejecuta en .NET Framework 4 o posterior, porque se omite el guión temporal de la cadena de búsqueda, al llamar al método para buscar una subcadena que consta del guion suave y "m" devuelve la posición de "m" en la cadena, mientras que llamarla para buscar una subcadena que consta del guion suave y "n" devuelve la posición de "n".

C#

int position = 0;
string s1 = "ani\u00ADmal";
string s2 = "animal";

// Find the index of the soft hyphen followed by "n".
position = s1.LastIndexOf("m");
Console.WriteLine($"'m' at position {position}");

if (position >= 0)
    Console.WriteLine(s1.LastIndexOf("\u00ADn", position));

position = s2.LastIndexOf("m");
Console.WriteLine($"'m' at position {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 {position}");

if (position >= 0)
    Console.WriteLine(s1.LastIndexOf("\u00ADm", position));

position = s2.LastIndexOf("m");
Console.WriteLine($"'m' at position {position}");

if (position >= 0)
    Console.WriteLine(s2.LastIndexOf("\u00ADm", position));

// The example displays the following output:
//
// 'm' at position 4
// 1
// 'm' at position 3
// 1
// 'm' at position 4
// 4
// 'm' at position 3
// 3

Notas a los autores de las llamadas

Como se explica en Procedimientos recomendados para usar cadenas, se recomienda evitar llamar a métodos de comparación de cadenas que sustituya los valores predeterminados y, en su lugar, llame a métodos que requieren que se especifiquen explícitamente los parámetros. Para buscar el índice de una subcadena que precede a una posición de carácter determinada mediante las reglas de comparación de la referencia cultural actual, indique su intención explícitamente llamando a la sobrecarga del método LastIndexOf(String, Int32, StringComparison) con un valor de CurrentCulture para su parámetro comparisonType. Si no necesita una comparación con reconocimiento lingüístico, considere la posibilidad de usar Ordinal.

Consulte también

• Int32
• IndexOf(Char)
• IndexOfAny(Char[])
• LastIndexOfAny(Char[])