String.IndexOf Método

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Indica el índice de base cero de la primera aparición de un carácter Unicode especificado o de una cadena en la instancia en cuestión. El método devuelve -1, si el carácter o cadena no se encuentran en esta instancia.

Sobrecargas

IndexOf(String, Int32, Int32, StringComparison)	Devuelve el índice de base cero de la primera aparición de la cadena especificada en el objeto String actual. Los parámetros indican la posición inicial de búsqueda en la cadena actual, el número de caracteres de la cadena actual en los que buscar y el tipo de búsqueda que se va a usar para la cadena especificada.
IndexOf(String, Int32, Int32)	Indica el índice de base cero de la primera aparición de la cadena especificada en la instancia en cuestión. La búsqueda comienza en una posición de carácter especificada y examina un número especificado de posiciones de caracteres.
IndexOf(Char, Int32, Int32)	Devuelve el índice de base en cero de la primera aparición del carácter especificado en la instancia en cuestión. La búsqueda comienza en una posición de carácter especificada y examina un número especificado de posiciones de caracteres.
IndexOf(String, StringComparison)	Devuelve el índice de base cero de la primera aparición de la cadena especificada en el objeto String actual. Un parámetro especifica el tipo de búsqueda que se va a usar para la cadena especificada.
IndexOf(String, Int32, StringComparison)	Devuelve el índice de base cero de la primera aparición de la cadena especificada en el objeto String actual. Los parámetros indican la posición inicial de búsqueda en la cadena actual y el tipo de búsqueda que se usa para la cadena especificada.
IndexOf(Char, StringComparison)	Devuelve el índice de base cero de la primera aparición del carácter Unicode especificado en esta cadena. Un parámetro especifica el tipo de búsqueda que se va a usar para el carácter especificado.
IndexOf(Char, Int32)	Devuelve el índice de base cero de la primera aparición del carácter Unicode especificado en esta cadena. La búsqueda comienza en una posición de carácter especificada.
IndexOf(String)	Indica el índice de base cero de la primera aparición de la cadena especificada en la instancia en cuestión.
IndexOf(Char)	Devuelve el índice de base cero de la primera aparición del carácter Unicode especificado en esta cadena.
IndexOf(String, Int32)	Indica el índice de base cero de la primera aparición de la cadena especificada en la instancia en cuestión. La búsqueda comienza en una posición de carácter especificada.

IndexOf(String, Int32, Int32, StringComparison)

Source:

String.Searching.cs

Devuelve el índice de base cero de la primera aparición de la cadena especificada en el objeto String actual. Los parámetros indican la posición inicial de búsqueda en la cadena actual, el número de caracteres de la cadena actual en los que buscar y el tipo de búsqueda que se va a usar para la cadena especificada.

C#

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

Parámetros

value

String

Cadena que se va a buscar.

startIndex

Int32

Posición en la que comienza la búsqueda.

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 de base cero del parámetro value desde el principio de la instancia actual si se encuentra esa cadena o, de lo contrario, -1. Si value es Empty, el valor devuelto es startIndex.

Excepciones

ArgumentNullException

value es null.

ArgumentOutOfRangeException

count o startIndex es negativo.

O bien

startIndex es mayor que la longitud de esta instancia.

O bien

count es mayor que la longitud de esta cadena menos startIndex.

ArgumentException

comparisonType no es un valor StringComparison válido.

Ejemplos

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

C#

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

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

class Sample 
{
    public static void Main() 
    {
    string intro = "Find the first 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 StringComparison. Specify the start 
// index and count. 

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

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

// Search using different values of StringComparison. 
    Console.WriteLine("\nPart 3: Neither start index nor count is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.IndexOf(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 first 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 0 (cero). El parámetro startIndex puede estar comprendido entre 0 y la longitud de la instancia de cadena.

La búsqueda comienza en startIndex y continúa hasta startIndex + count -1. El carácter de no startIndex + count se incluye en la búsqueda.

El comparisonType parámetro especifica que se va a buscar el value parámetro mediante la referencia cultural actual o invariable, mediante una búsqueda que distingue mayúsculas de minúsculas o que no distingue mayúsculas de minúsculas y se usan reglas de comparación ordinal de palabras.

Notas a los autores de las llamadas

Los juegos de caracteres incluyen caracteres que se pueden pasar por alto, que son los caracteres que no se tienen en cuenta al realizar una comparación lingüística o en la que se tiene en cuenta la referencia cultural. En una búsqueda que tiene en cuenta la referencia cultural (es decir, si comparisonType no es Ordinal o OrdinalIgnoreCase), si value contiene un carácter que se puede pasar por alto, el resultado es equivalente a buscar sin ese carácter. Si value solo consta de uno o varios caracteres ignorables, el IndexOf(String, Int32, Int32, StringComparison) método siempre devuelve startIndex, que es la posición del carácter en la que comienza la búsqueda.

En el ejemplo siguiente, el IndexOf(String, Int32, Int32, StringComparison) método se usa para buscar la posición de un guión suave (U+00AD) seguido de una "m" comenzando en la tercera a la sexta posición de caracteres 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 que se puede omitir, 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, encuentra la subcadena solo en la primera cadena. Tenga en cuenta que, en el caso de la primera cadena, que incluye el guión flexible seguido de un "m", el método no devuelve el índice del guión suave, pero en su lugar devuelve el índice de la "m" cuando realiza una comparación que distingue la referencia cultural. El método devuelve el índice del guion virtual de la primera cadena solo cuando realiza una comparación ordinal.

C#

using System;

public class Example
{
    public static void Main()
    {

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

        Console.WriteLine(s1.IndexOf(searchString, 2, 4, StringComparison.CurrentCulture));
        Console.WriteLine(s1.IndexOf(searchString, 2, 4, StringComparison.Ordinal));
        Console.WriteLine(s2.IndexOf(searchString, 2, 4, StringComparison.CurrentCulture));
        Console.WriteLine(s2.IndexOf(searchString, 2, 4, StringComparison.Ordinal));

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

IndexOf(String, Int32, Int32)

Source:

String.Searching.cs

Indica el índice de base cero de la primera aparición de la cadena especificada en la instancia en cuestión. La búsqueda comienza en una posición de carácter especificada y examina un número especificado de posiciones de caracteres.

C#

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

Parámetros

value

String

Cadena que se va a buscar.

startIndex

Int32

Posición en la que comienza la búsqueda.

count

Int32

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

Devoluciones

Int32

Posición de índice de base cero de value desde el principio de la instancia actual si se encuentra esa cadena o, de lo contrario, -1. Si value es Empty, el valor devuelto es startIndex.

Excepciones

ArgumentNullException

value es null.

ArgumentOutOfRangeException

count o startIndex es negativo.

O bien

startIndex es mayor que la longitud de esta cadena.

O bien

count es mayor que la longitud de esta cadena menos startIndex.

Ejemplos

En el ejemplo siguiente se busca el índice de todas las apariciones de la cadena "he" dentro de una subcadena de otra cadena. Tenga en cuenta que el número de caracteres que se van a buscar debe volver a calcular para cada iteración de búsqueda.

C#

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

end = str.Length;
start = end/2;
Console.WriteLine();
Console.WriteLine("All occurrences of 'he' from position {0} to {1}.", start, end-1);
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 <= end) && (at > -1))
{
    // start+count must be a position within -str-.
    count = end - start;
    at = str.IndexOf("he", start, count);
    if (at == -1) break;
    Console.Write("{0} ", at);
    start = at+1;
}
Console.WriteLine();

/*
This example produces the following results:

All occurrences of 'he' from position 34 to 68.
0----+----1----+----2----+----3----+----4----+----5----+----6----+---
012345678901234567890123456789012345678901234567890123456789012345678
Now is the time for all good men to come to the aid of their country.

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

*/

Comentarios

La numeración de índice comienza desde 0 (cero). El parámetro startIndex puede estar comprendido entre 0 y la longitud de la instancia de 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. La búsqueda comienza en startIndex y continúa hasta startIndex + count -1. El carácter de no startIndex + count se incluye en la búsqueda.

Los juegos de caracteres incluyen caracteres que se pueden pasar por alto, que son los caracteres que no se tienen en cuenta al realizar una comparación lingüística o en la que se tiene en cuenta la referencia cultural. En una búsqueda que tiene en cuenta la referencia cultural, si value contiene un carácter que se puede pasar por alto, el resultado es equivalente a buscar sin ese carácter. Si value solo consta de uno o varios caracteres ignorables, el IndexOf(String, Int32, Int32) método siempre devuelve startIndex, que es la posición del carácter en la que comienza la búsqueda. En el ejemplo siguiente, el IndexOf(String, Int32, Int32) método se usa para buscar la posición de un guión suave (U+00AD) seguido de una "m" comenzando en la tercera a la sexta posición de caracteres 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 que se puede omitir, el método devuelve el índice de "m" en la cadena cuando realiza una comparación que distingue la referencia cultural. Observe que en el caso de la primera cadena, que incluye el guion virtual seguido de una "m", el método no devuelve el índice del guion virtual, sino el índice de "m".

C#

using System;

public class Example
{
    public static void Main()
    {
        string searchString = "\u00ADm";
        string s1 = "ani\u00ADmal" ;
        string s2 = "animal";

        Console.WriteLine(s1.IndexOf(searchString, 2, 4));
        Console.WriteLine(s2.IndexOf(searchString, 2, 4));

        // The example displays the following output:
        //       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 parámetros. Para usar las reglas de comparación de la referencia cultural actual para realizar esta operación, indique su intención explícitamente llamando a la sobrecarga del IndexOf(String, Int32, Int32, StringComparison) método con un valor de CurrentCulture para su comparisonType parámetro. Si no necesita una comparación con reconocimiento lingüístico, considere la posibilidad de usar Ordinal.

Consulte también

• Int32
• CultureInfo
• IndexOfAny(Char[])
• LastIndexOf(Char)
• LastIndexOfAny(Char[])

IndexOf(Char, Int32, Int32)

Source:

String.Searching.cs

Devuelve el índice de base en cero de la primera aparición del carácter especificado en la instancia en cuestión. La búsqueda comienza en una posición de carácter especificada y examina un número especificado de posiciones de caracteres.

C#

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

Parámetros

value

Char

Carácter Unicode que se va a buscar.

startIndex

Int32

Posición en la que comienza la búsqueda.

count

Int32

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

Devoluciones

Int32

Posición de índice de base cero de value desde el principio de la cadena si se encuentra ese carácter, o -1 en caso contrario.

Excepciones

ArgumentOutOfRangeException

count o startIndex es negativo.

O bien

startIndex es mayor que la longitud de esta cadena.

O bien

count es mayor que la longitud de esta cadena menos startIndex.

Ejemplos

En el siguiente ejemplo se muestra el IndexOf método.

C#

// Example for the String.IndexOf( char, int, int ) method.
using System;

class IndexOfCII 
{
    public static void Main() 
    {
        string br1 = 
            "0----+----1----+----2----+----3----+----" +
            "4----+----5----+----6----+----7";
        string br2 = 
            "0123456789012345678901234567890123456789" +
            "0123456789012345678901234567890";
        string str = 
            "ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi " +
            "ABCDEFGHI abcdefghi ABCDEFGHI";

        Console.WriteLine( 
            "This example of String.IndexOf( char, int, int )\n" +
            "generates the following output." );
        Console.WriteLine( 
            "{0}{1}{0}{2}{0}{3}{0}", 
            Environment.NewLine, br1, br2, str );

        FindAllChar( 'A', str );
        FindAllChar( 'a', str );
        FindAllChar( 'I', str );
        FindAllChar( 'i', str );
        FindAllChar( '@', str );
        FindAllChar( ' ', str );
    }

    static void FindAllChar( Char target, String searched )
    {
        Console.Write( 
            "The character '{0}' occurs at position(s): ", 
            target );

        int     startIndex = -1;
        int     hitCount = 0;

        // Search for all occurrences of the target.
        while( true )
        {
            startIndex = searched.IndexOf( 
                target, startIndex + 1, 
                searched.Length - startIndex - 1 );

            // Exit the loop if the target is not found.
            if( startIndex < 0 )
                break;

            Console.Write( "{0}, ", startIndex );
            hitCount++;
        }

        Console.WriteLine( "occurrences: {0}", hitCount );
    }
}

/*
This example of String.IndexOf( char, int, int )
generates the following output.

0----+----1----+----2----+----3----+----4----+----5----+----6----+----7
01234567890123456789012345678901234567890123456789012345678901234567890
ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi ABCDEFGHI abcdefghi ABCDEFGHI

The character 'A' occurs at position(s): 0, 20, 40, 60, occurrences: 4
The character 'a' occurs at position(s): 10, 30, 50, occurrences: 3
The character 'I' occurs at position(s): 8, 28, 48, 68, occurrences: 4
The character 'i' occurs at position(s): 18, 38, 58, occurrences: 3
The character '@' occurs at position(s): occurrences: 0
The character ' ' occurs at position(s): 9, 19, 29, 39, 49, 59, occurrences: 6
*/

Comentarios

La búsqueda comienza en startIndex y continúa hasta startIndex + count -1. El carácter de no startIndex + count se incluye en la búsqueda.

La numeración de índices comienza desde 0 (cero). El parámetro startIndex puede estar comprendido entre 0 y la longitud de la instancia de cadena.

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 iguales. Para realizar una búsqueda que tenga en cuenta la referencia cultural, use el CompareInfo.IndexOf método , 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
• IndexOfAny(Char[])
• LastIndexOf(Char)
• LastIndexOfAny(Char[])

IndexOf(String, StringComparison)

Source:

String.Searching.cs

Devuelve el índice de base cero de la primera aparición de la cadena especificada en el objeto String actual. Un parámetro especifica el tipo de búsqueda que se va a usar para la cadena especificada.

C#

public int IndexOf (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 del parámetro value si se encuentra la cadena; de lo contrario, -1. Si value es Empty, el valor devuelto es 0.

Excepciones

ArgumentNullException

value es null.

ArgumentException

comparisonType no es un valor StringComparison válido.

Ejemplos

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

C#

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

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

class Sample 
{
    public static void Main() 
    {
    string intro = "Find the first 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 StringComparison. Specify the start 
// index and count. 

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

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

// Search using different values of StringComparison. 
    Console.WriteLine("\nPart 3: Neither start index nor count is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.IndexOf(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 first occurrence of a character using different values of StringComparison.
The current culture is "en-US" - English (United States).
Search for the string "Å" in the string "A Cheshire ca°t"

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

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

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

*/

Comentarios

La numeración de índices comienza desde cero.

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

Notas a los autores de las llamadas

Los juegos de caracteres incluyen caracteres que se pueden pasar por alto, que son los caracteres que no se tienen en cuenta al realizar una comparación lingüística o en la que se tiene en cuenta la referencia cultural. En una búsqueda que tiene en cuenta la referencia cultural (es decir, si comparisonType no es Ordinal o OrdinalIgnoreCase), si value contiene un carácter que se puede pasar por alto, el resultado es equivalente a buscar sin ese carácter. Si value solo consta de uno o varios caracteres ignorables, el IndexOf(String, StringComparison) método siempre devuelve 0 (cero) para indicar que la coincidencia se encuentra al principio de la instancia actual.

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

C#

using System;

public class Example
{
    public static void Main()
    {
        string s1 = "ani\u00ADmal";
        string s2 = "animal";
      
        Console.WriteLine("Culture-sensitive comparison:");
        // Use culture-sensitive comparison to find the soft hyphen.
        Console.WriteLine(s1.IndexOf("\u00AD", StringComparison.CurrentCulture));
        Console.WriteLine(s2.IndexOf("\u00AD", StringComparison.CurrentCulture));
      
        // Use culture-sensitive comparison to find the soft hyphen followed by "n".
        Console.WriteLine(s1.IndexOf("\u00ADn", StringComparison.CurrentCulture));
        Console.WriteLine(s2.IndexOf("\u00ADn", StringComparison.CurrentCulture));
      
        // Use culture-sensitive comparison to find the soft hyphen followed by "m".
        Console.WriteLine(s1.IndexOf("\u00ADm", StringComparison.CurrentCulture));
        Console.WriteLine(s2.IndexOf("\u00ADm", StringComparison.CurrentCulture));
      
        Console.WriteLine("Ordinal comparison:");
        // Use ordinal comparison to find the soft hyphen.
        Console.WriteLine(s1.IndexOf("\u00AD", StringComparison.Ordinal));
        Console.WriteLine(s2.IndexOf("\u00AD", StringComparison.Ordinal));
      
        // Use ordinal comparison to find the soft hyphen followed by "n".
        Console.WriteLine(s1.IndexOf("\u00ADn", StringComparison.Ordinal));
        Console.WriteLine(s2.IndexOf("\u00ADn", StringComparison.Ordinal));
      
        // Use ordinal comparison to find the soft hyphen followed by "m".
        Console.WriteLine(s1.IndexOf("\u00ADm", StringComparison.Ordinal));
        Console.WriteLine(s2.IndexOf("\u00ADm", StringComparison.Ordinal));

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

IndexOf(String, Int32, StringComparison)

Source:

String.Searching.cs

Devuelve el índice de base cero de la primera aparición de la cadena especificada en el objeto String actual. Los parámetros indican la posición inicial de búsqueda en la cadena actual y el tipo de búsqueda que se usa para la cadena especificada.

C#

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

Parámetros

value

String

Cadena que se va a buscar.

startIndex

Int32

Posición en la que comienza la búsqueda.

comparisonType

StringComparison

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

Devoluciones

Int32

Posición de índice de base cero del parámetro value desde el principio de la instancia actual si se encuentra esa cadena o, de lo contrario, -1. Si value es Empty, el valor devuelto es startIndex.

Excepciones

ArgumentNullException

value es null.

ArgumentOutOfRangeException

startIndex es menor que 0 (cero) o mayor que la longitud de esta instancia.

ArgumentException

comparisonType no es un valor StringComparison válido.

Ejemplos

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

C#

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

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

class Sample 
{
    public static void Main() 
    {
    string intro = "Find the first 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 StringComparison. Specify the start 
// index and count. 

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

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

// Search using different values of StringComparison. 
    Console.WriteLine("\nPart 3: Neither start index nor count is specified.");
    foreach (StringComparison sc in scValues)
        {
        loc = cat.IndexOf(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 first occurrence of a character using different values of StringComparison.
The current culture is "en-US" - English (United States).
Search for the string "Å" in the string "A Cheshire ca°t"

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

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

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

*/

Comentarios

La numeración de índices comienza a partir de 0. El parámetro startIndex puede estar comprendido entre 0 y la longitud de la instancia de cadena. Si startIndex es igual a la longitud de la instancia de cadena, el método devuelve -1.

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

Notas a los autores de las llamadas

Los juegos de caracteres incluyen caracteres que se pueden pasar por alto, que son los caracteres que no se tienen en cuenta al realizar una comparación lingüística o en la que se tiene en cuenta la referencia cultural. En una búsqueda que tiene en cuenta la referencia cultural (es decir, si comparisonType no es Ordinal o OrdinalIgnoreCase), si value contiene un carácter que se puede pasar por alto, el resultado es equivalente a buscar sin ese carácter. Si value solo consta de uno o varios caracteres ignorables, el IndexOf(String, Int32, StringComparison) método siempre devuelve startIndex, que es la posición de carácter en la que comienza la búsqueda.

En el ejemplo siguiente, el IndexOf(String, Int32, StringComparison) método se usa para buscar la posición de un guión suave (U+00AD) seguido de una "m" empezando por la tercera posición de carácter 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 guion flexible es un carácter que se puede omitir, el método devuelve el índice de "m" en la cadena cuando realiza una comparación que distingue referencias culturales. Observe que en el caso de la primera cadena, que incluye el guion virtual seguido de una "m", el método no devuelve el índice del guion virtual, sino el índice de "m". El método devuelve el índice del guion virtual de la primera cadena solo cuando realiza una comparación ordinal.

C#

using System;

public class Example
{
    public static void Main()
    {
      
        string searchString = "\u00ADm";
        string s1 = "ani\u00ADmal" ;
        string s2 = "animal";

        Console.WriteLine(s1.IndexOf(searchString, 2, StringComparison.CurrentCulture));
        Console.WriteLine(s1.IndexOf(searchString, 2, StringComparison.Ordinal));
        Console.WriteLine(s2.IndexOf(searchString, 2, StringComparison.CurrentCulture));
        Console.WriteLine(s2.IndexOf(searchString, 2, StringComparison.Ordinal));

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

IndexOf(Char, StringComparison)

Source:

String.Searching.cs

Devuelve el índice de base cero de la primera aparición del carácter Unicode especificado en esta cadena. Un parámetro especifica el tipo de búsqueda que se va a usar para el carácter especificado.

C#

public int IndexOf (char value, StringComparison comparisonType);

Parámetros

value

Char

Carácter que se va a buscar.

comparisonType

StringComparison

Valor de enumeración que especifica las reglas de la búsqueda.

Devoluciones

Int32

Devuelve el índice de base cero de value si se encuentra dicho carácter; de lo contrario, devuelve -1.

Excepciones

ArgumentException

comparisonType no es un valor StringComparison válido.

Comentarios

La numeración de índices comienza desde cero.

El comparisonType parámetro es un StringComparison miembro de enumeración que especifica si la búsqueda del value argumento usa la referencia cultural actual o invariable, distingue mayúsculas de minúsculas o no distingue entre mayúsculas y minúsculas, o usa reglas de comparación ordinal de palabras.

IndexOf(Char, Int32)

Source:

String.Searching.cs

Devuelve el índice de base cero de la primera aparición del carácter Unicode especificado en esta cadena. La búsqueda comienza en una posición de carácter especificada.

C#

public int IndexOf (char value, int startIndex);

Parámetros

value

Char

Carácter Unicode que se va a buscar.

startIndex

Int32

Posición en la que comienza la búsqueda.

Devoluciones

Int32

Posición de índice de base cero de value desde el principio de la cadena si se encuentra ese carácter, o -1 en caso contrario.

Excepciones

ArgumentOutOfRangeException

startIndex es menor que 0 (cero) o mayor que la longitud de la cadena.

Ejemplos

En el siguiente ejemplo se muestra el IndexOf método.

C#

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

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

at = 0;
start = 0;
while((start < str.Length) && (at > -1))
{
    at = str.IndexOf('t', start);
    if (at == -1) break;
    Console.Write("{0} ", at);
    start = at+1;
}
Console.WriteLine();

/*
This example produces the following results:

All occurrences of 't' from position 0 to 68.
0----+----1----+----2----+----3----+----4----+----5----+----6----+---
012345678901234567890123456789012345678901234567890123456789012345678
Now is the time for all good men to come to the aid of their country.

The letter 't' occurs at position(s): 7 11 33 41 44 55 65

*/

Comentarios

La numeración de índices comienza a partir de 0. El parámetro startIndex puede estar comprendido entre 0 y la longitud de la instancia de cadena. Si startIndex es igual a la longitud de la instancia de cadena, el método devuelve -1.

La búsqueda va de startIndex hasta el final de la cadena.

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 iguales. Para realizar una búsqueda que tenga en cuenta la referencia cultural, use el CompareInfo.IndexOf método , 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

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

IndexOf(String)

Source:

String.Searching.cs

Indica el índice de base cero de la primera aparición de la cadena especificada en la instancia en cuestión.

C#

public int IndexOf (string value);

Parámetros

value

String

Cadena que se va a buscar.

Devoluciones

Int32

Devuelve la posición de índice de base cero de value si se encuentra dicha cadena; de lo contrario, devuelve -1. Si value es Empty, el valor devuelto es 0.

Excepciones

ArgumentNullException

value es null.

Ejemplos

En el ejemplo siguiente se busca "n" en "animal". Dado que los índices de cadena comienzan en cero en lugar de uno, el IndexOf(String) método indica que "n" está en la posición 1.

C#

String str = "animal";
String toFind = "n";
int index = str.IndexOf("n");
Console.WriteLine("Found '{0}' in '{1}' at position {2}",
                toFind, str, index);

// The example displays the following output:
//        Found 'n' in 'animal' at position 1

En el ejemplo siguiente se usa el IndexOf método para determinar la posición inicial de un nombre animal en una oración. A continuación, utiliza esta posición para insertar un adjetivo que describa al animal en la oración.

C#

using System;

public class Example {
    public static void Main()
    {
        string animal1 = "fox";
        string animal2 = "dog";

        string strTarget = String.Format("The {0} jumps over the {1}.",
                                         animal1, animal2);

        Console.WriteLine("The original string is:{0}{1}{0}",
                          Environment.NewLine, strTarget);

        Console.Write("Enter an adjective (or group of adjectives) " +
                      "to describe the {0}: ==> ", animal1);
        string adj1 = Console.ReadLine();

        Console.Write("Enter an adjective (or group of adjectives) " +
                      "to describe the {0}: ==> ", animal2);
        string adj2 = Console.ReadLine();

        adj1 = adj1.Trim() + " ";
        adj2 = adj2.Trim() + " ";

        strTarget = strTarget.Insert(strTarget.IndexOf(animal1), adj1);
        strTarget = strTarget.Insert(strTarget.IndexOf(animal2), adj2);

        Console.WriteLine("{0}The final string is:{0}{1}",
                          Environment.NewLine, strTarget);
    }
}
// Output from the example might appear as follows:
//       The original string is:
//       The fox jumps over the dog.
//
//       Enter an adjective (or group of adjectives) to describe the fox: ==> bold
//       Enter an adjective (or group of adjectives) to describe the dog: ==> lazy
//
//       The final string is:
//       The bold fox jumps over the lazy dog.

Comentarios

La numeración de índices comienza desde cero.

Este método realiza una búsqueda de palabras (distingue mayúsculas de minúsculas y de referencia cultural) mediante la referencia cultural actual. La búsqueda comienza en la primera posición de carácter de esta instancia y continúa hasta la última posición del carácter.

Los juegos de caracteres incluyen caracteres que se pueden pasar por alto, que son los caracteres que no se tienen en cuenta al realizar una comparación lingüística o en la que se tiene en cuenta la referencia cultural. En una búsqueda que tiene en cuenta la referencia cultural, si value contiene un carácter que se puede pasar por alto, el resultado es equivalente a buscar sin ese carácter. Si value solo consta de uno o varios caracteres ignorables, el IndexOf(String) método siempre devuelve 0 (cero) para indicar que la coincidencia se encuentra al principio de la instancia actual. En el ejemplo siguiente, el IndexOf(String) método se usa para buscar tres subcadenas (un guion suave (U+00AD), un guion suave seguido de "n" y un guión suave seguido de "m") en dos cadenas. Solo una de las cadenas contiene un guion virtual. Si el ejemplo se ejecuta en .NET Framework 4 o posterior, en cada caso, porque el guion flexible es un carácter que se puede pasar por alto, el resultado es el mismo que si el guion suave no se hubiera incluido en value. Al buscar solo un guión suave, el método devuelve 0 (cero) para indicar que ha encontrado una coincidencia al principio de la cadena.

C#

using System;

public class Example
{
    public static void Main()
    {
        string s1 = "ani\u00ADmal";
        string s2 = "animal";
      
        // Find the index of the soft hyphen.
        Console.WriteLine(s1.IndexOf("\u00AD"));
        Console.WriteLine(s2.IndexOf("\u00AD"));
      
        // Find the index of the soft hyphen followed by "n".
        Console.WriteLine(s1.IndexOf("\u00ADn"));
        Console.WriteLine(s2.IndexOf("\u00ADn"));
      
        // Find the index of the soft hyphen followed by "m".
        Console.WriteLine(s1.IndexOf("\u00ADm"));
        Console.WriteLine(s2.IndexOf("\u00ADm"));

        // The example displays the following output
        // if run under the .NET Framework 4 or later:
        //       0
        //       0
        //       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 parámetros. Para buscar el primer í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 IndexOf(String, StringComparison) método con un valor de CurrentCulture para su comparisonType parámetro. Si no necesita una comparación con reconocimiento lingüístico, considere la posibilidad de usar Ordinal.

Consulte también

• Int32
• CultureInfo
• IndexOfAny(Char[])
• LastIndexOf(Char)
• LastIndexOfAny(Char[])

IndexOf(Char)

Source:

String.Searching.cs

Devuelve el índice de base cero de la primera aparición del carácter Unicode especificado en esta cadena.

C#

public int IndexOf (char value);

Parámetros

value

Char

Carácter Unicode que se va a buscar.

Devoluciones

Int32

Devuelve la posición de índice de base cero de value si se encuentra dicho carácter; de lo contrario, devuelve -1.

Ejemplos

En el ejemplo siguiente se muestra cómo puede buscar un String carácter mediante el IndexOf método .

C#

// Create a Unicode string with 5 Greek Alpha characters.
String szGreekAlpha = new String('\u0391',5);

// Create a Unicode string with 3 Greek Omega characters.
String szGreekOmega = "\u03A9\u03A9\u03A9";

String szGreekLetters = String.Concat(szGreekOmega, szGreekAlpha, 
                                    szGreekOmega.Clone());

// Display the entire string.
Console.WriteLine("The string: {0}", szGreekLetters);

// The first index of Alpha.
int ialpha = szGreekLetters.IndexOf('\u0391');
// The first index of Omega.
int iomega = szGreekLetters.IndexOf('\u03A9');

Console.WriteLine("First occurrence of the Greek letter Alpha: Index {0}", 
                ialpha);
Console.WriteLine("First occurrence of the Greek letter Omega: Index {0}", 
                iomega);

// The example displays the following output:
//    The string: ΩΩΩΑΑΑΑΑΩΩΩ
//    First occurrence of the Greek letter Alpha: Index 3
//    First occurrence of the Greek letter Omega: Index 0

Comentarios

La numeración de índices comienza desde cero.

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 iguales. Para realizar una búsqueda sensible a la referencia cultural, use el CompareInfo.IndexOf método , 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
• IndexOfAny(Char[])
• LastIndexOf(Char)
• LastIndexOfAny(Char[])

IndexOf(String, Int32)

Source:

String.Searching.cs

Indica el índice de base cero de la primera aparición de la cadena especificada en la instancia en cuestión. La búsqueda comienza en una posición de carácter especificada.

C#

public int IndexOf (string value, int startIndex);

Parámetros

value

String

Cadena que se va a buscar.

startIndex

Int32

Posición en la que comienza la búsqueda.

Devoluciones

Int32

Posición de índice de base cero de value desde el principio de la instancia actual si se encuentra esa cadena o, de lo contrario, -1. Si value es Empty, el valor devuelto es startIndex.

Excepciones

ArgumentNullException

value es null.

ArgumentOutOfRangeException

startIndex es menor que 0 (cero) o mayor que la longitud de esta instancia.

Ejemplos

En el ejemplo siguiente se buscan todas las apariciones de una cadena especificada dentro de una cadena de destino.

C#

using System;

public class IndexOfTest {
    public static void Main() {

        string strSource = "This is the string which we will perform the search on";

        Console.WriteLine("The search string is:{0}\"{1}\"{0}", Environment.NewLine, strSource);

        string strTarget = "";
        int found = 0;
        int totFinds = 0;

        do {
            Console.Write("Please enter a search value to look for in the above string (hit Enter to exit) ==> ");

            strTarget = Console.ReadLine();

            if (strTarget != "") {

                for (int i = 0; i < strSource.Length; i++) {

                    found = strSource.IndexOf(strTarget, i);

                    if (found >= 0) {
                        totFinds++;
                        i = found;
                    }
                    else
                    {
                        break;
                    }
                }
            }
            else
            {
                return;
            }

            Console.WriteLine("{0}The search parameter '{1}' was found {2} times.{0}",
                    Environment.NewLine, strTarget, totFinds);

            totFinds = 0;
        } while ( true );
    }
}

Comentarios

La numeración de índices comienza desde 0. El parámetro startIndex puede estar comprendido entre 0 y la longitud de la instancia de cadena. Si startIndex es igual a la longitud de la instancia de cadena, el método devuelve -1.

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. La búsqueda comienza en la startIndex posición del carácter de esta instancia y continúa hasta la última posición del carácter.

Los juegos de caracteres incluyen caracteres que se pueden pasar por alto, que son los caracteres que no se tienen en cuenta al realizar una comparación lingüística o en la que se tiene en cuenta la referencia cultural. En una búsqueda que tiene en cuenta la referencia cultural, si value contiene un carácter que se puede pasar por alto, el resultado es equivalente a buscar sin ese carácter. Si value solo consta de uno o varios caracteres ignorables, el IndexOf(String, Int32) método siempre devuelve startIndex, que es la posición del carácter en la que comienza la búsqueda. En el ejemplo siguiente, el IndexOf(String, Int32) método se usa para buscar la posición de un guión suave (U+00AD) seguido de una "m" 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 guion flexible es un carácter que se puede omitir, el método devuelve el índice de "m" en la cadena. Observe que en el caso de la primera cadena, que incluye el guion virtual seguido de una "m", el método no devuelve el índice del guion virtual, sino el índice de "m".

C#

using System;

public class Example
{
    public static void Main()
    {
        string searchString = "\u00ADm";
        string s1 = "ani\u00ADmal" ;
        string s2 = "animal";

        Console.WriteLine(s1.IndexOf(searchString, 2));
        Console.WriteLine(s2.IndexOf(searchString, 2));

        // The example displays the following output:
        //       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 parámetros. Para buscar el primer índice de una subcadena que se produce después de 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 IndexOf(String, Int32, StringComparison) método con un valor de CurrentCulture para su comparisonType parámetro. Si no necesita una comparación con reconocimiento lingüístico, considere la posibilidad de usar Ordinal.

Consulte también

• Int32
• CultureInfo
• IndexOfAny(Char[])
• LastIndexOf(Char)
• LastIndexOfAny(Char[])