String.IndexOf Metodo

Definizione

Spazio dei nomi:

System

Assembly:

System.Runtime.dll

Restituisce l'indice in base zero della prima occorrenza di un carattere Unicode specificato o di una stringa all'interno di questa istanza. Il metodo restituisce -1 se la stringa o il carattere non viene trovato nell'istanza.

Overload

IndexOf(String, Int32, Int32, StringComparison)	Restituisce l'indice in base zero della prima occorrenza della stringa specificata nell'oggetto String corrente. I parametri specificano la posizione di ricerca iniziale nella stringa corrente, il numero di caratteri nella stringa corrente in cui eseguire la ricerca e il tipo di ricerca da usare per la stringa specificata.
IndexOf(String, Int32, Int32)	Restituisce l'indice in base zero della prima occorrenza della stringa specificata in questa istanza. La ricerca viene eseguita iniziando dalla posizione specificata dei caratteri ed esamina un determinato numero di posizioni.
IndexOf(Char, Int32, Int32)	Restituisce l'indice in base zero della prima occorrenza del carattere specificato in questa istanza. La ricerca viene eseguita iniziando dalla posizione specificata dei caratteri ed esamina un determinato numero di posizioni.
IndexOf(String, StringComparison)	Restituisce l'indice in base zero della prima occorrenza della stringa specificata nell'oggetto String corrente. Un parametro specifica il tipo di ricerca da usare per la stringa specificata.
IndexOf(String, Int32, StringComparison)	Restituisce l'indice in base zero della prima occorrenza della stringa specificata nell'oggetto String corrente. I parametri specificano la posizione iniziale della ricerca nella stringa corrente e il tipo di ricerca da usare per la stringa specificata.
IndexOf(Char, StringComparison)	Restituisce l'indice in base zero della prima occorrenza del carattere Unicode specificato in questa stringa. Un parametro specifica il tipo di ricerca da usare per il carattere specificato.
IndexOf(Char, Int32)	Restituisce l'indice in base zero della prima occorrenza del carattere Unicode specificato in questa stringa. La ricerca ha inizio alla posizione del carattere specificata.
IndexOf(String)	Restituisce l'indice in base zero della prima occorrenza della stringa specificata in questa istanza.
IndexOf(Char)	Restituisce l'indice in base zero della prima occorrenza del carattere Unicode specificato in questa stringa.
IndexOf(String, Int32)	Restituisce l'indice in base zero della prima occorrenza della stringa specificata in questa istanza. La ricerca ha inizio alla posizione del carattere specificata.

IndexOf(String, Int32, Int32, StringComparison)

Origine:

String.Searching.cs

Restituisce l'indice in base zero della prima occorrenza della stringa specificata nell'oggetto String corrente. I parametri specificano la posizione di ricerca iniziale nella stringa corrente, il numero di caratteri nella stringa corrente in cui eseguire la ricerca e il tipo di ricerca da usare per la stringa specificata.

C#

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

Parametri

value

String

Stringa da cercare.

startIndex

Int32

Posizione iniziale della ricerca.

count

Int32

Numero di posizioni dei caratteri da esaminare.

comparisonType

StringComparison

Uno dei valori di enumerazione che specifica le regole di ricerca.

Restituisce

Int32

Posizione dell'indice in base zero del parametro value dall'inizio dell'istanza corrente se la stringa viene trovata oppure -1 in caso contrario. Se value è Empty, il valore restituito è startIndex.

Eccezioni

ArgumentNullException

value è null.

ArgumentOutOfRangeException

count o startIndex è negativo.

-oppure-

startIndex è maggiore della lunghezza di questa istanza.

-oppure-

count è maggiore della lunghezza di questa stringa meno startIndex.

ArgumentException

comparisonType non è un valore valido di StringComparison.

Esempio

Nell'esempio seguente vengono illustrati tre overload del IndexOf metodo che trovano la prima occorrenza di una stringa all'interno di un'altra stringa usando valori diversi dell'enumerazione StringComparison .

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

*/

Commenti

La numerazione dell'indice inizia da 0 (zero). Il parametro startIndex può avere un valore compreso tra 0 e la lunghezza dell'istanza della stringa.

La ricerca inizia da startIndex e continua a startIndex + count -1. Il carattere in startIndex + count non è incluso nella ricerca.

Il comparisonType parametro specifica di cercare il value parametro usando le impostazioni cultura correnti o invarianti, usando una ricerca senza distinzione tra maiuscole e minuscole o senza distinzione tra maiuscole e minuscole e usando regole di confronto ordinali o parola.

Note per i chiamanti

I set di caratteri includono caratteri ignorabili, ovvero caratteri che non sono considerati durante l'esecuzione di un confronto linguistico o dipendente dalle impostazioni cultura. In una ricerca dipendente dalle impostazioni cultura (ovvero se comparisonType non è Ordinal o OrdinalIgnoreCase), se value contiene un carattere ignorable, il risultato è equivalente alla ricerca con il carattere rimosso. Se value è costituito solo da uno o più caratteri ignorabili, il IndexOf(String, Int32, Int32, StringComparison) metodo restituisce startIndexsempre , ovvero la posizione del carattere in corrispondenza della quale inizia la ricerca.

Nell'esempio seguente, il IndexOf(String, Int32, Int32, StringComparison) metodo viene usato per trovare la posizione di un trattino morbido (U+00AD) seguito da un "m" a partire dalla terza alla sesta posizione di caratteri in due stringhe. Solo una delle stringhe contiene la sottostringa richiesta. Se l'esempio viene eseguito in .NET Framework 4 o versione successiva, in entrambi i casi, poiché il trattino morbido è un carattere ignorabile, il metodo restituisce l'indice di "m" nella stringa quando esegue un confronto sensibile alle impostazioni cultura. Quando esegue un confronto ordinale, tuttavia, trova la sottostringa solo nella prima stringa. Si noti che nel caso della prima stringa, che include il trattino morbido seguito da un "m", il metodo non restituisce l'indice del trattino morbido, ma restituisce invece l'indice di "m" quando esegue un confronto con distinzione tra impostazioni cultura. Il metodo restituisce l'indice del segno meno facoltativo nella prima stringa solo quando esegue un confronto ordinale.

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)

Origine:

String.Searching.cs

Restituisce l'indice in base zero della prima occorrenza della stringa specificata in questa istanza. La ricerca viene eseguita iniziando dalla posizione specificata dei caratteri ed esamina un determinato numero di posizioni.

C#

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

Parametri

value

String

Stringa da cercare.

startIndex

Int32

Posizione iniziale della ricerca.

count

Int32

Numero di posizioni dei caratteri da esaminare.

Restituisce

Int32

Posizione dell'indice in base zero di value dall'inizio dell'istanza corrente se la stringa viene trovata oppure -1 in caso contrario. Se value è Empty, il valore restituito è startIndex.

Eccezioni

ArgumentNullException

value è null.

ArgumentOutOfRangeException

count o startIndex è negativo.

-oppure-

startIndex è maggiore della lunghezza di questa stringa.

-oppure-

count è maggiore della lunghezza di questa stringa meno startIndex.

Esempio

Nell'esempio seguente viene trovato l'indice di tutte le occorrenze della stringa "he" all'interno di una sottostringa di un'altra stringa. Si noti che il numero di caratteri da cercare deve essere ricalcolato per ogni iterazione di ricerca.

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

*/

Commenti

La numerazione dell'indice inizia da 0 (zero). Il parametro startIndex può avere un valore compreso tra 0 e la lunghezza dell'istanza della stringa.

Questo metodo esegue una ricerca di parole (con distinzione tra maiuscole e minuscole e con distinzione tra impostazioni cultura) usando le impostazioni cultura correnti. La ricerca inizia da startIndex e continua a startIndex + count -1. Il carattere in startIndex + count non è incluso nella ricerca.

I set di caratteri includono caratteri ignorabili, ovvero caratteri che non sono considerati durante l'esecuzione di un confronto linguistico o dipendente dalle impostazioni cultura. In una ricerca dipendente dalle impostazioni cultura, se value contiene un carattere ignorabile, il risultato è equivalente alla ricerca con il carattere rimosso. Se value è costituito solo da uno o più caratteri ignorabili, il IndexOf(String, Int32, Int32) metodo restituisce startIndexsempre , ovvero la posizione del carattere in corrispondenza della quale inizia la ricerca. Nell'esempio seguente, il IndexOf(String, Int32, Int32) metodo viene usato per trovare la posizione di un trattino morbido (U+00AD) seguito da un "m" a partire dalla terza alla sesta posizione di caratteri in due stringhe. Solo una delle stringhe contiene la sottostringa richiesta. Se l'esempio viene eseguito in .NET Framework 4 o versione successiva, in entrambi i casi, poiché il trattino morbido è un carattere ignorabile, il metodo restituisce l'indice di "m" nella stringa quando esegue un confronto sensibile alle impostazioni cultura. Si noti che nel caso della prima stringa, che include il segno meno facoltativo seguito da una "m", il metodo non restituisce l'indice del segno meno facoltativo, ma l'indice di "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
    }
}

Note per i chiamanti

Come illustrato in Procedure consigliate per l'uso di stringhe, è consigliabile evitare di chiamare metodi di confronto tra stringhe che sostituiscono i valori predefiniti e chiamare invece metodi che richiedono parametri da specificare in modo esplicito. Per usare le regole di confronto delle impostazioni cultura correnti per eseguire questa operazione, segnalare in modo esplicito l'intenzione chiamando l'overload del IndexOf(String, Int32, Int32, StringComparison) metodo con un valore di CurrentCulture per il comparisonType relativo parametro. Se non è necessario un confronto con riconoscimento linguistico, è consigliabile usare Ordinal.

Vedi anche

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

IndexOf(Char, Int32, Int32)

Origine:

String.Searching.cs

Restituisce l'indice in base zero della prima occorrenza del carattere specificato in questa istanza. La ricerca viene eseguita iniziando dalla posizione specificata dei caratteri ed esamina un determinato numero di posizioni.

C#

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

Parametri

value

Char

Carattere Unicode da cercare.

startIndex

Int32

Posizione iniziale della ricerca.

count

Int32

Numero di posizioni dei caratteri da esaminare.

Restituisce

Int32

Posizione dell'indice in base zero di value dall'inizio della stringa se viene trovato il carattere oppure -1 in caso contrario.

Eccezioni

ArgumentOutOfRangeException

count o startIndex è negativo.

-oppure-

startIndex è maggiore della lunghezza di questa stringa.

-oppure-

count è maggiore della lunghezza di questa stringa meno startIndex.

Esempio

Nell'esempio seguente viene illustrato il IndexOf metodo.

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

Commenti

La ricerca inizia a startIndex e continua a startIndex + count -1. Il carattere in startIndex + count corrispondenza non è incluso nella ricerca.

Il numero di indice inizia da 0 (zero). Il parametro startIndex può avere un valore compreso tra 0 e la lunghezza dell'istanza della stringa.

Questo metodo esegue una ricerca ordinale (insensibile dalle impostazioni cultura), in cui un carattere viene considerato equivalente a un altro carattere solo se i valori scalari Unicode sono uguali. Per eseguire una ricerca sensibile alle impostazioni cultura, usare il CompareInfo.IndexOf metodo, in cui un valore scalare Unicode che rappresenta un carattere precomposto, ad esempio la legatura "Æ" (U+00C6), può essere considerata equivalente a qualsiasi occorrenza dei componenti del carattere nella sequenza corretta, ad esempio "AE" (U+0041, U+0045), a seconda delle impostazioni cultura.

Vedi anche

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

IndexOf(String, StringComparison)

Origine:

String.Searching.cs

Restituisce l'indice in base zero della prima occorrenza della stringa specificata nell'oggetto String corrente. Un parametro specifica il tipo di ricerca da usare per la stringa specificata.

C#

public int IndexOf (string value, StringComparison comparisonType);

Parametri

value

String

Stringa da cercare.

comparisonType

StringComparison

Uno dei valori di enumerazione che specifica le regole di ricerca.

Restituisce

Int32

Posizione dell'indice del parametro value se tale stringa viene trovata; in caso contrario, -1. Se value è Empty, il valore restituito è 0.

Eccezioni

ArgumentNullException

value è null.

ArgumentException

comparisonType non è un valore valido di StringComparison.

Esempio

Nell'esempio seguente vengono illustrati tre overload del IndexOf metodo che trovano la prima occorrenza di una stringa all'interno di un'altra stringa usando valori diversi dell'enumerazione StringComparison .

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

*/

Commenti

Il numero di indice inizia da zero.

Il comparisonType parametro specifica per cercare il value parametro usando le impostazioni cultura correnti o invarianti, usando una ricerca senza distinzione tra maiuscole e minuscole o usando regole di confronto ordinali o di word.

Note per i chiamanti

I set di caratteri includono caratteri ignorabili, ovvero caratteri che non sono considerati durante l'esecuzione di un confronto linguistico o dipendente dalle impostazioni cultura. In una ricerca dipendente dalle impostazioni cultura (ovvero se comparisonType non è Ordinal o OrdinalIgnoreCase), se value contiene un carattere ignorable, il risultato è equivalente alla ricerca con il carattere rimosso. Se value è costituito solo da uno o più caratteri ignorabili, il IndexOf(String, StringComparison) metodo restituisce sempre 0 (zero) per indicare che la corrispondenza viene trovata all'inizio dell'istanza corrente.

Nell'esempio seguente viene usato il IndexOf(String, StringComparison) metodo per trovare tre sottostringa (un trattino morbido (U+00AD), un trattino morbido seguito da "n" e un trattino morbido seguito da "m") in due stringhe. Solo una delle stringhe contiene un segno meno facoltativo. Se l'esempio viene eseguito in .NET Framework 4 o versione successiva, poiché il trattino morbido è un carattere ignorabile, una ricerca sensibile alle impostazioni cultura restituisce lo stesso valore restituito se il trattino leggero non è incluso nella stringa di ricerca. Una ricerca ordinale, tuttavia, trova correttamente il trattino morbido in una stringa e segnala che è assente dalla seconda stringa.

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)

Origine:

String.Searching.cs

Restituisce l'indice in base zero della prima occorrenza della stringa specificata nell'oggetto String corrente. I parametri specificano la posizione iniziale della ricerca nella stringa corrente e il tipo di ricerca da usare per la stringa specificata.

C#

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

Parametri

value

String

Stringa da cercare.

startIndex

Int32

Posizione iniziale della ricerca.

comparisonType

StringComparison

Uno dei valori di enumerazione che specifica le regole di ricerca.

Restituisce

Int32

Posizione dell'indice in base zero del parametro value dall'inizio dell'istanza corrente se la stringa viene trovata oppure -1 in caso contrario. Se value è Empty, il valore restituito è startIndex.

Eccezioni

ArgumentNullException

value è null.

ArgumentOutOfRangeException

startIndex è minore di 0 (zero) o maggiore della lunghezza della stringa.

ArgumentException

comparisonType non è un valore valido di StringComparison.

Esempio

Nell'esempio seguente vengono illustrati tre overload del IndexOf metodo che trovano la prima occorrenza di una stringa all'interno di un'altra stringa usando valori diversi dell'enumerazione StringComparison .

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

*/

Commenti

Il numero di indice inizia da 0. Il parametro startIndex può avere un valore compreso tra 0 e la lunghezza dell'istanza della stringa. Se startIndex corrisponde alla lunghezza dell'istanza di stringa, il metodo restituisce -1.

Il comparisonType parametro specifica per cercare il value parametro usando le impostazioni cultura correnti o invarianti, usando una ricerca senza distinzione tra maiuscole e minuscole o usando regole di confronto ordinali o di word.

Note per i chiamanti

I set di caratteri includono caratteri ignorabili, ovvero caratteri che non sono considerati durante l'esecuzione di un confronto linguistico o dipendente dalle impostazioni cultura. In una ricerca dipendente dalle impostazioni cultura (ovvero se comparisonType non è Ordinal o OrdinalIgnoreCase), se value contiene un carattere ignorable, il risultato è equivalente alla ricerca con il carattere rimosso. Se value è costituito solo da uno o più caratteri ignorabili, il IndexOf(String, Int32, StringComparison) metodo restituisce startIndexsempre , ovvero la posizione del carattere in corrispondenza della quale inizia la ricerca.

Nell'esempio seguente viene usato il IndexOf(String, Int32, StringComparison) metodo per trovare la posizione di un trattino morbido (U+00AD) seguito da un "m" a partire dalla terza posizione del carattere in due stringhe. Solo una delle stringhe contiene la sottostringa richiesta. Se l'esempio viene eseguito in .NET Framework 4 o versioni successive, in entrambi i casi, poiché il trattino morbido è un carattere ignorabile, il metodo restituisce l'indice di "m" nella stringa quando esegue un confronto con distinzione tra impostazioni cultura. Si noti che nel caso della prima stringa, che include il segno meno facoltativo seguito da una "m", il metodo non restituisce l'indice del segno meno facoltativo, ma l'indice di "m". Il metodo restituisce l'indice del segno meno facoltativo nella prima stringa solo quando esegue un confronto ordinale.

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)

Origine:

String.Searching.cs

Restituisce l'indice in base zero della prima occorrenza del carattere Unicode specificato in questa stringa. Un parametro specifica il tipo di ricerca da usare per il carattere specificato.

C#

public int IndexOf (char value, StringComparison comparisonType);

Parametri

value

Char

Il carattere da cercare.

comparisonType

StringComparison

Un valore di enumerazione che specifica le regole per la ricerca.

Restituisce

Int32

Posizione dell'indice in base zero di value se viene trovato il carattere, in caso contrario -1.

Eccezioni

ArgumentException

comparisonType non è un valore valido di StringComparison.

Commenti

Il numero di indice inizia da zero.

Il comparisonType parametro è un StringComparison membro di enumerazione che specifica se la ricerca dell'argomento value usa le impostazioni cultura correnti o invarianti, è distinzione tra maiuscole e minuscole o senza distinzione tra maiuscole e minuscole o usa regole di confronto ordinali o parole.

IndexOf(Char, Int32)

Origine:

String.Searching.cs

Restituisce l'indice in base zero della prima occorrenza del carattere Unicode specificato in questa stringa. La ricerca ha inizio alla posizione del carattere specificata.

C#

public int IndexOf (char value, int startIndex);

Parametri

value

Char

Carattere Unicode da cercare.

startIndex

Int32

Posizione iniziale della ricerca.

Restituisce

Int32

Posizione dell'indice in base zero di value dall'inizio della stringa se viene trovato il carattere oppure -1 in caso contrario.

Eccezioni

ArgumentOutOfRangeException

startIndex è minore di 0 (zero) o maggiore della lunghezza della stringa.

Esempio

Nell'esempio seguente viene illustrato il IndexOf metodo.

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

*/

Commenti

Il numero di indice inizia da 0. Il parametro startIndex può avere un valore compreso tra 0 e la lunghezza dell'istanza della stringa. Se startIndex corrisponde alla lunghezza dell'istanza di stringa, il metodo restituisce -1.

La ricerca varia da startIndex alla fine della stringa.

Questo metodo esegue una ricerca ordinale (insensibile dalle impostazioni cultura), in cui un carattere viene considerato equivalente a un altro carattere solo se i valori scalari Unicode sono uguali. Per eseguire una ricerca sensibile alle impostazioni cultura, usare il CompareInfo.IndexOf metodo, in cui un valore scalare Unicode che rappresenta un carattere precomposto, ad esempio la legatura "Æ" (U+00C6), può essere considerata equivalente a qualsiasi occorrenza dei componenti del carattere nella sequenza corretta, ad esempio "AE" (U+0041, U+0045), a seconda delle impostazioni cultura.

Vedi anche

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

IndexOf(String)

Origine:

String.Searching.cs

Restituisce l'indice in base zero della prima occorrenza della stringa specificata in questa istanza.

C#

public int IndexOf (string value);

Parametri

value

String

Stringa da cercare.

Restituisce

Int32

Posizione dell'indice in base zero di value se viene trovata la stringa; in caso contrario, -1. Se value è Empty, il valore restituito è 0.

Eccezioni

ArgumentNullException

value è null.

Esempio

L'esempio seguente cerca "n" in "animale". Poiché gli indici stringa iniziano a zero anziché uno, il IndexOf(String) metodo indica che "n" è in posizione 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

Nell'esempio seguente viene usato il IndexOf metodo per determinare la posizione iniziale di un nome animale in una frase. Usa quindi questa posizione per inserire un aggettivo che descrive l'animale nella frase.

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.

Commenti

Il numero di indice inizia da zero.

Questo metodo esegue una ricerca con distinzione tra maiuscole e minuscole e cultura usando le impostazioni cultura correnti. La ricerca inizia alla prima posizione di carattere di questa istanza e continua fino all'ultima posizione del carattere.

I set di caratteri includono caratteri ignorabili, ovvero caratteri che non sono considerati durante l'esecuzione di un confronto linguistico o dipendente dalle impostazioni cultura. In una ricerca dipendente dalle impostazioni cultura, se value contiene un carattere ignorabile, il risultato è equivalente alla ricerca con il carattere rimosso. Se value è costituito solo da uno o più caratteri ignorabili, il IndexOf(String) metodo restituisce sempre 0 (zero) per indicare che la corrispondenza viene trovata all'inizio dell'istanza corrente. Nell'esempio seguente viene usato il IndexOf(String) metodo per trovare tre sottostringa (un trattino morbido (U+00AD), un trattino morbido seguito da "n" e un trattino morbido seguito da "m") in due stringhe. Solo una delle stringhe contiene un segno meno facoltativo. Se l'esempio viene eseguito in .NET Framework 4 o versioni successive, in ogni caso, perché il trattino morbido è un carattere ignorabile, il risultato è lo stesso se il trattino morbido non era stato incluso in value. Quando si cerca solo un trattino morbido, il metodo restituisce 0 (zero) per indicare che ha trovato una corrispondenza all'inizio della stringa.

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

Note per i chiamanti

Come illustrato in Procedure consigliate per l'uso di stringhe, è consigliabile evitare di chiamare metodi di confronto stringa che sostituisci i valori predefiniti e chiamare i metodi che richiedono parametri da specificare in modo esplicito. Per trovare il primo indice di una sottostringa all'interno di un'istanza di stringa usando le regole di confronto delle impostazioni cultura correnti, segnalare in modo esplicito l'intenzione chiamando l'overload del IndexOf(String, StringComparison) metodo con un valore di CurrentCulture per il relativo comparisonType parametro. Se non è necessario un confronto con riconoscimento linguistico, prendere in considerazione l'uso di Ordinal.

Vedi anche

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

IndexOf(Char)

Origine:

String.Searching.cs

Restituisce l'indice in base zero della prima occorrenza del carattere Unicode specificato in questa stringa.

C#

public int IndexOf (char value);

Parametri

value

Char

Carattere Unicode da cercare.

Restituisce

Int32

Posizione dell'indice in base zero di value se viene trovato il carattere; in caso contrario, -1.

Esempio

Nell'esempio seguente viene illustrato come cercare un String carattere usando il IndexOf metodo .

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

Commenti

La numerazione dell'indice inizia da zero.

Questo metodo esegue una ricerca ordinale (senza distinzione tra impostazioni cultura), in cui un carattere viene considerato equivalente a un altro carattere solo se i valori scalari Unicode sono uguali. Per eseguire una ricerca sensibile alle impostazioni cultura, usare il CompareInfo.IndexOf metodo , in cui un valore scalare Unicode che rappresenta un carattere precomposto, ad esempio la legatura "Æ" (U+00C6), può essere considerato equivalente a qualsiasi occorrenza dei componenti del carattere nella sequenza corretta, ad esempio "AE" (U+0041, U+0045), a seconda delle impostazioni cultura.

Vedi anche

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

IndexOf(String, Int32)

Origine:

String.Searching.cs

Restituisce l'indice in base zero della prima occorrenza della stringa specificata in questa istanza. La ricerca ha inizio alla posizione del carattere specificata.

C#

public int IndexOf (string value, int startIndex);

Parametri

value

String

Stringa da cercare.

startIndex

Int32

Posizione iniziale della ricerca.

Restituisce

Int32

Posizione dell'indice in base zero di value dall'inizio dell'istanza corrente se la stringa viene trovata oppure -1 in caso contrario. Se value è Empty, il valore restituito è startIndex.

Eccezioni

ArgumentNullException

value è null.

ArgumentOutOfRangeException

startIndex è minore di 0 (zero) o maggiore della lunghezza della stringa.

Esempio

Nell'esempio seguente viene eseguita la ricerca di tutte le occorrenze di una stringa specificata all'interno di una stringa di destinazione.

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

Commenti

La numerazione dell'indice inizia da 0. Il parametro startIndex può avere un valore compreso tra 0 e la lunghezza dell'istanza della stringa. Se startIndex è uguale alla lunghezza dell'istanza di stringa, il metodo restituisce -1.

Questo metodo esegue una ricerca di parole (con distinzione tra maiuscole e minuscole e con distinzione tra impostazioni cultura) usando le impostazioni cultura correnti. La ricerca inizia in corrispondenza della startIndex posizione del carattere di questa istanza e continua fino all'ultima posizione del carattere.

I set di caratteri includono caratteri ignorabili, ovvero caratteri che non sono considerati durante l'esecuzione di un confronto linguistico o dipendente dalle impostazioni cultura. In una ricerca dipendente dalle impostazioni cultura, se value contiene un carattere ignorabile, il risultato è equivalente alla ricerca con il carattere rimosso. Se value è costituito solo da uno o più caratteri ignorabili, il IndexOf(String, Int32) metodo restituisce startIndexsempre , ovvero la posizione del carattere in corrispondenza della quale inizia la ricerca. Nell'esempio seguente il IndexOf(String, Int32) metodo viene usato per trovare la posizione di un trattino morbido (U+00AD) seguito da un "m" in due stringhe. Solo una delle stringhe contiene la sottostringa richiesta. Se l'esempio viene eseguito in .NET Framework 4 o versione successiva, in entrambi i casi, poiché il trattino morbido è un carattere ignorabile, il metodo restituisce l'indice di "m" nella stringa. Si noti che nel caso della prima stringa, che include il segno meno facoltativo seguito da una "m", il metodo non restituisce l'indice del segno meno facoltativo, ma l'indice di "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
    }
}

Note per i chiamanti

Come illustrato in Procedure consigliate per l'uso di stringhe, è consigliabile evitare di chiamare metodi di confronto tra stringhe che sostituiscono i valori predefiniti e chiamare invece metodi che richiedono parametri da specificare in modo esplicito. Per trovare il primo indice di una sottostringa che si verifica dopo una determinata posizione di carattere usando le regole di confronto delle impostazioni cultura correnti, segnalare in modo esplicito l'intenzione chiamando l'overload del IndexOf(String, Int32, StringComparison) metodo con un valore di CurrentCulture per il relativo comparisonType parametro. Se non è necessario un confronto con riconoscimento linguistico, è consigliabile usare Ordinal.

Vedi anche

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