Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo String.LastIndexOf (String, Int32)

 

Restituisce la posizione nell'indice in base zero dell'ultima occorrenza di una stringa specificata all'interno di questa istanza. La ricerca inizia in corrispondenza di una posizione di carattere specificata e continua all'indietro verso l'inizio della stringa.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

public int LastIndexOf(
	string value,
	int startIndex
)

Parametri

value
Type: System.String

Stringa da cercare.

startIndex
Type: System.Int32

Posizione iniziale della ricerca. La ricerca procede da startIndex verso l'inizio dell'istanza.

Valore restituito

Type: System.Int32

Posizione dell'indice iniziale in base zero di value se tale stringa viene trovata oppure -1 se non viene trovata o se l'istanza corrente è uguale a String.Empty. Se value è String.Empty, il valore restituito sarà il più piccolo tra startIndex e l'ultima posizione dell'indice in questa istanza.

Exception Condition
ArgumentNullException

value è null.

ArgumentOutOfRangeException

L'istanza corrente non è uguale a String.Empty e startIndex è minore di zero oppure maggiore della lunghezza dell'istanza corrente.

-oppure-

L'istanza corrente equivale a String.Empty e startIndex è minore di -1 o maggiore di zero.

Numerazione dell'indice inizia da zero. Vale a dire il primo carattere nella stringa è in corrispondenza dell'indice zero e l'ultimo si trova in Length - 1.

La ricerca inizia in corrispondenza di startIndex posizione di questa istanza e procede a ritroso verso l'inizio fino al carattere value viene trovato o viene esaminata la posizione del primo carattere. Ad esempio, se startIndex è Length - 1, il metodo esegue ricerche in ogni carattere dall'ultimo carattere della stringa all'inizio.

Questo metodo esegue una ricerca di word (maiuscole/minuscole e distinzione delle impostazioni cultura) usando le impostazioni cultura correnti.

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 è composta solo da uno o più caratteri ignorabili, il LastIndexOf(String, Int32) metodo restituisce sempre startIndex, ovvero la posizione del carattere in corrispondenza del quale inizia la ricerca. Nell'esempio seguente, il LastIndexOf(String, Int32) metodo viene utilizzato per trovare una sottostringa che include un segno meno facoltativo (U + 00AD) e che precede o che include la "m" finale in una stringa. Se viene eseguito l'esempio di .NET Framework 4 o versione successiva, perché viene ignorato il segno meno facoltativo nella stringa di ricerca, la chiamata al metodo per trovare una sottostringa che include il segno meno facoltativo e "m" restituisce la posizione di "m" nella stringa, mentre questo viene chiamato per trovare una sottostringa che include il segno meno e "n" restituisce la posizione di "n". Quando la stringa di ricerca contiene solo il segno, il metodo restituisce l'indice di "m", che rappresenta il valore di startIndex.

using System;

public class Example
{
   public static void Main()
   {
      int position = 0;
      string s1 = "ani\u00ADmal";
      string s2 = "animal";

      // Find the index of the soft hyphen.
      position = s1.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)
         Console.WriteLine(s1.LastIndexOf("\u00AD", position));

      position = s2.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)   
         Console.WriteLine(s2.LastIndexOf("\u00AD", position));

      // Find the index of the soft hyphen followed by "n".
      position = s1.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)
         Console.WriteLine(s1.LastIndexOf("\u00ADn", position));

      position = s2.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)   
         Console.WriteLine(s2.LastIndexOf("\u00ADn", position));

      // Find the index of the soft hyphen followed by "m".
      position = s1.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)
         Console.WriteLine(s1.LastIndexOf("\u00ADm", position));

      position = s2.LastIndexOf("m");
      Console.WriteLine("'m' at position {0}", position);
      if (position >= 0)   
         Console.WriteLine(s2.LastIndexOf("\u00ADm", position));
   }
}
// The example displays the following output:
//       'm' at position 4
//       4
//       'm' at position 3
//       3
//       'm' at position 4
//       1
//       'm' at position 3
//       1
//       'm' at position 4
//       4
//       'm' at position 3
//       3

Note per i chiamanti:

Come spiegato in Procedure consigliate per l'utilizzo di stringhe in .NET Framework, è consigliabile evitare di chiamare i metodi di confronto tra stringhe che sostituiscono i valori predefiniti e di chiamano invece i metodi che richiedono parametri per specificare in modo esplicito. Per trovare l'indice di una sottostringa che precede una particolare posizione di carattere utilizzando le regole di confronto delle impostazioni cultura correnti, chiamare il LastIndexOf(String, Int32, StringComparison) overload del metodo con un valore di StringComparison.CurrentCulture per relativo comparisonType parametro.

Nell'esempio seguente trova l'indice di tutte le occorrenze di una stringa nella stringa di destinazione, a partire dalla fine della stringa di destinazione fino all'inizio della stringa di destinazione.

// Sample for String.LastIndexOf(String, Int32)
using System;

class Sample {
    public static void Main() {

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

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

    at = 0;
    while((start > -1) && (at > -1))
        {
        at = str.LastIndexOf("he", start);
        if (at > -1) 
            {
            Console.Write("{0} ", at);
            start = at - 1;
            }
        }
    Console.Write("{0}{0}{0}", Environment.NewLine);
    }
}
/*
This example produces the following results:
All occurrences of 'he' from position 66 to 0.
0----+----1----+----2----+----3----+----4----+----5----+----6----+-
0123456789012345678901234567890123456789012345678901234567890123456
Now is the time for all good men to come to the aid of their party.

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


*/

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 1.1
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: