Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Classe String

Rappresenta testo come una serie di caratteri Unicode.

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

[SerializableAttribute]
[ComVisibleAttribute(true)]
public sealed class String : IComparable, 
	ICloneable, IConvertible, IComparable<string>, IEnumerable<char>, 
	IEnumerable, IEquatable<string>

Il tipo String espone i seguenti membri.

  NomeDescrizione
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreString(Char*)Consente di inizializzare una nuova istanza della classe String sul valore indicato da uno specifico puntatore a una matrice di caratteri Unicode.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreString(Char[])Consente di inizializzare una nuova istanza della classe String sul valore indicato da una matrice di caratteri Unicode.
Metodo pubblicoSupportato da XNA FrameworkString(SByte*)Consente di inizializzare una nuova istanza della classe String sul valore indicato da un puntatore a una matrice di valori interi con segno a 8 bit.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreString(Char, Int32)Consente di inizializzare una nuova istanza della classe String sul valore indicato da uno specifico carattere Unicode ripetuto un numero precisato di volte.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreString(Char*, Int32, Int32)Consente di inizializzare una nuova istanza della classe String sul valore indicato da uno specifico puntatore a una matrice di caratteri Unicode, da una posizione iniziale del carattere all'interno di tale matrice e da una lunghezza.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreString(Char[], Int32, Int32)Consente di inizializzare una nuova istanza della classe String sul valore indicato da una matrice di caratteri Unicode, da una posizione iniziale del carattere all'interno di tale matrice e da una lunghezza.
Metodo pubblicoString(SByte*, Int32, Int32)Consente di inizializzare una nuova istanza della classe String sul valore indicato da uno specifico puntatore a una matrice di interi con segno a 8 bit, da una posizione iniziale all'interno di tale matrice e da una lunghezza.
Metodo pubblicoString(SByte*, Int32, Int32, Encoding)Consente di inizializzare una nuova istanza della classe String sul valore indicato da uno specifico puntatore a una matrice di interi con segno a 8 bit, da una posizione iniziale all'interno di tale matrice e da un oggetto Encoding.
In alto

  NomeDescrizione
Proprietà pubblicaSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreCharsOttiene l'oggetto Char in una posizione specificata dell'oggetto String corrente.
Proprietà pubblicaSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreLengthOttiene il numero di caratteri nell'oggetto String corrente.
In alto

  NomeDescrizione
Metodo pubblicoSupportato da XNA FrameworkClone Restituisce un riferimento a questa istanza della classe String.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreCompare(String, String)Confronta due oggetti String specificati e restituisce un valore intero che ne indica la posizione relativa nei criteri di ordinamento.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkCompare(String, String, Boolean)Confronta due oggetti String specificati, ignorando o rispettando la distinzione tra maiuscole e minuscole, e restituisce un intero che ne indica la posizione relativa nell'ordinamento.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreCompare(String, String, StringComparison)Confronta due oggetti String specificati utilizzando le regole specificate e restituisce un intero che ne indica la posizione relativa nell'ordinamento.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkCompare(String, String, Boolean, CultureInfo)Confronta due oggetti String specificati, ignorando o rispettando la distinzione tra maiuscole e minuscole e utilizzando le informazioni specifiche sulle impostazioni cultura per influenzare il confronto, e restituisce un intero che ne indica la posizione relativa nell'ordinamento.
Metodo pubblicoMembro staticoSupportato da Libreria di classi portabileCompare(String, String, CultureInfo, CompareOptions)Confronta due oggetti String specificati, utilizzando le opzioni di confronto specificate e le informazioni specifiche delle impostazioni cultura per influenzare il confronto, e restituisce un intero che indica la relazione reciproca tra le due stringhe nell'ordinamento.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreCompare(String, Int32, String, Int32, Int32)Confronta le sottostringhe di due oggetti String specificati e restituisce un intero che indica la relativa posizione nell'ordinamento.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkCompare(String, Int32, String, Int32, Int32, Boolean)Confronta le sottostringhe di due oggetti String specificati, ignorando o rispettando la distinzione tra maiuscole e minuscole, e restituisce un intero che ne indica la posizione relativa nell'ordinamento.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreCompare(String, Int32, String, Int32, Int32, StringComparison)Confronta sottostringhe di due oggetti String specificati utilizzando le regole specificate e restituisce un intero che ne indica la posizione relativa nell'ordinamento.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkCompare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)Confronta sottostringhe di due oggetti String specificati, ignorando o rispettando la distinzione tra maiuscole e minuscole e utilizzando le informazioni specifiche sulle impostazioni cultura per influenzare il confronto, e restituisce un intero che ne indica la posizione relativa nell'ordinamento.
Metodo pubblicoMembro staticoCompare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)Confronta le sottostringhe di due oggetti String specificati, utilizzando le opzioni di confronto specificate e le informazioni specifiche delle impostazioni cultura per influenzare il confronto, e restituisce un intero che indica la relazione reciproca tra le due sottostringhe nell'ordinamento.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreCompareOrdinal(String, String)Consente di confrontare due oggetti String specificati in base all'analisi dei valori numerici dei corrispondenti oggetti Char in ciascuna stringa.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreCompareOrdinal(String, Int32, String, Int32, Int32)Consente effettuare il confronto fra sottostringhe di due determinati oggetti String in base all'analisi dei valori numerici dei corrispondenti oggetti Char in ciascuna sottostringa.
Metodo pubblicoSupportato da XNA FrameworkCompareTo(Object)Confronta questa istanza con Object o un oggetto specificato e indica se questa istanza precede, segue o si trova nella stessa posizione dell'oggetto Object specificato all'interno dei criteri di ordinamento.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreCompareTo(String)Confronta questa istanza con un oggettoString specificato e indica se questa istanza precede, segue o si trova nella stessa posizione dell'oggetto String specificato all'interno dei criteri di ordinamento.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreConcat(Object)Crea la rappresentazione di stringa di un oggetto specificato.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreConcat(Object[])Consente di concatenare le rappresentazioni in forma di stringa degli elementi in una matrice Object specificata.
Metodo pubblicoMembro staticoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreConcat(IEnumerable<String>)Concatena i membri di una raccolta IEnumerable<T> costruita di tipo String.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreConcat(String[])Consente di concatenare gli elementi di una matrice di oggetti String specificati.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreConcat(Object, Object)Consente di concatenare le rappresentazioni di stringa di due oggetti specificati.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreConcat(String, String)Consente di concatenare due istanze specificate della classe String.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreConcat(Object, Object, Object)Consente di concatenare le rappresentazioni di stringa di tre oggetti specificati.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreConcat(String, String, String)Consente di concatenare tre istanze specificate della classe String.
Metodo pubblicoMembro staticoConcat(Object, Object, Object, Object)Consente di concatenare le rappresentazioni di stringhe di quattro oggetti specificati e di qualsiasi oggetto specificato in un elenco di parametri di lunghezza variabile facoltativo.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreConcat(String, String, String, String)Consente di concatenare quattro istanze specificate della classe String.
Metodo pubblicoMembro staticoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreConcat<T>(IEnumerable<T>)Concatena i membri di un'implementazione di IEnumerable<T>.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreContainsRestituisce un valore che indica se una sottostringa specificata è presente all'interno della stringa.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkCopyConsente di creare una nuova istanza dell'oggetto String con lo stesso valore di una istanza dell'oggetto String specificata.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreCopyToConsente di copiare un numero definito di caratteri da una posizione specificata in questa istanza in una posizione specificata in una matrice di caratteri Unicode.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreEndsWith(String)Consente di determinare se la fine di questa istanza di stringa corrisponde alla stringa specificata.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreEndsWith(String, StringComparison)Consente di determinare se la fine di questa istanza di stringa corrisponde alla stringa specificata se confrontata utilizzando l'opzione di confronto specificata.
Metodo pubblicoEndsWith(String, Boolean, CultureInfo)Consente di determinare se la fine di questa istanza di stringa corrisponde alla stringa specificata se confrontata utilizzando le impostazioni cultura specificate.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreEquals(Object)Determina se questa istanza e un oggetto specificato, che deve essere anche un oggetto String, hanno lo stesso valore. (Esegue l'override di Object.Equals(Object)).
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreEquals(String)Consente di determinare se questa istanza e un altro oggetto String specificato hanno lo stesso valore.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreEquals(String, String)Consente di determinare se due oggetti String specificati hanno lo stesso valore.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreEquals(String, StringComparison)Consente di determinare se questa stringa e un oggetto String specificato hanno lo stesso valore. Un parametro consente di specificare le impostazioni cultura, l'eventuale distinzione fra maiuscole e minuscole e le regole di ordinamento utilizzate per effettuare il confronto.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreEquals(String, String, StringComparison)Consente di determinare se due oggetti String specificati hanno lo stesso valore. Un parametro consente di specificare le impostazioni cultura, l'eventuale distinzione fra maiuscole e minuscole e le regole di ordinamento utilizzate per effettuare il confronto.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkFormat(String, Object)Consente di sostituire uno o più elementi di formato in una stringa specificata con la rappresentazione in forma di stringa di un oggetto specificato.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreFormat(String, Object[])Consente di sostituire l'elemento di formato presente in una stringa specificata con la rappresentazione in forma di stringa di un oggetto corrispondente in una matrice specificata.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreFormat(IFormatProvider, String, Object[])Consente di sostituire gli elementi di formato presenti in una stringa specificata con le rappresentazioni in forma di stringa di oggetti corrispondenti in una matrice specificata. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkFormat(String, Object, Object)Consente di sostituire gli elementi di formato presenti in una stringa specificata con la rappresentazione di stringa di due oggetti specificati.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkFormat(String, Object, Object, Object)Consente di sostituire gli elementi di formato in una stringa specificata con le rappresentazioni in forma di stringa di tre oggetti specificati.
Metodo pubblicoSupportato da XNA FrameworkGetEnumeratorConsente di recuperare un oggetto che può scorrere fra i singoli caratteri di questa stringa.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreGetHashCodeRestituisce il codice hash per questa stringa. (Esegue l'override di Object.GetHashCode()).
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreGetType Ottiene il Type dell'istanza corrente. (Ereditato da Object)
Metodo pubblicoSupportato da XNA FrameworkGetTypeCodeRestituisce l'oggetto TypeCode per la classe String.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreIndexOf(Char)Restituisce l'indice in base zero della prima occorrenza del carattere Unicode specificato in questa stringa.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreIndexOf(String)Restituisce l'indice in base zero della prima occorrenza della stringa specificata in questa istanza.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreIndexOf(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.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreIndexOf(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.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreIndexOf(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 utilizzare per la stringa specificata.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreIndexOf(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 e esamina un determinato numero di posizioni.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreIndexOf(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 e esamina un determinato numero di posizioni.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreIndexOf(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 utilizzare per la stringa specificata.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreIndexOf(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 effettuare la ricerca e il tipo di ricerca da utilizzare per la stringa specificata.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreIndexOfAny(Char[])Restituisce l'indice in base zero della prima occorrenza in questa istanza di qualsiasi carattere presente in una matrice specificata di caratteri Unicode.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreIndexOfAny(Char[], Int32)Restituisce l'indice in base zero della prima occorrenza in questa istanza di qualsiasi carattere presente in una matrice specificata di caratteri Unicode. La ricerca ha inizio alla posizione del carattere specificata.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreIndexOfAny(Char[], Int32, Int32)Restituisce l'indice in base zero della prima occorrenza in questa istanza di qualsiasi carattere presente in una matrice specificata di caratteri Unicode. La ricerca viene eseguita iniziando dalla posizione specificata dei caratteri e esamina un determinato numero di posizioni.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreInsertRestituisce una nuova stringa in cui una stringa specificata viene inserita in una posizione di indice specificata in questa istanza.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkInternRecupera il riferimento del sistema all'oggetto String specificato.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkIsInternedRecupera un riferimento a un oggetto String specificato.
Metodo pubblicoIsNormalized()Specifica se la stringa è nel formato di normalizzazione Unicode C.
Metodo pubblicoIsNormalized(NormalizationForm)Specifica se la stringa è nel formato di normalizzazione Unicode indicato.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreIsNullOrEmptyIndica se la stringa specificata è null o una stringa Empty.
Metodo pubblicoMembro staticoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreIsNullOrWhiteSpaceIndica se una stringa specificata è null, vuota o è composta solo da spazi vuoti.
Metodo pubblicoMembro staticoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreJoin(String, IEnumerable<String>)Concatena i membri di una raccolta IEnumerable<T> costruita di tipo String, utilizzando tra i membri il separatore specificato.
Metodo pubblicoMembro staticoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreJoin(String, Object[])Concatena gli elementi di una matrice di oggetti, utilizzando tra gli elementi il separatore specificato.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreJoin(String, String[])Concatena tutti gli elementi di una matrice di stringhe, utilizzando tra gli elementi il separatore specificato.
Metodo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreJoin(String, String[], Int32, Int32)Concatena gli elementi specificati di una matrice di stringhe, utilizzando tra gli elementi il separatore specificato.
Metodo pubblicoMembro staticoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreJoin<T>(String, IEnumerable<T>)Concatena i membri di un insieme, utilizzando tra i membri il separatore specificato.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreLastIndexOf(Char)Restituisce l'indice in base zero dell'ultima occorrenza di un carattere Unicode specificato all'interno di questa istanza.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreLastIndexOf(String)Restituisce l'indice in base zero dell'ultima occorrenza di una stringa specificata all'interno di questa istanza.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreLastIndexOf(Char, Int32)Restituisce l'indice in base zero dell'ultima occorrenza di un carattere Unicode specificato 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.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreLastIndexOf(String, Int32)Restituisce l'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.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreLastIndexOf(String, StringComparison)Restituisce l'indice in base zero dell'ultima occorrenza di una stringa specificata all'interno dell'oggetto String corrente. Un parametro specifica il tipo di ricerca da utilizzare per la stringa specificata.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreLastIndexOf(Char, Int32, Int32)Restituisce l'indice in base zero dell'ultima occorrenza del carattere Unicode specificato in una sottostringa all'interno di questa istanza. La ricerca inizia in una posizione di carattere specificata e continua indietro verso l'inizio della stringa per un determinato numero di posizioni dei caratteri.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreLastIndexOf(String, Int32, Int32)Restituisce l'indice in base zero dell'ultima occorrenza di una stringa specificata all'interno di questa istanza. La ricerca inizia in una posizione di carattere specificata e continua indietro verso l'inizio della stringa per un determinato numero di posizioni dei caratteri.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreLastIndexOf(String, Int32, StringComparison)Restituisce l'indice in base zero dell'ultima occorrenza di una stringa specificata all'interno dell'oggetto String corrente. La ricerca inizia in corrispondenza di una posizione di carattere specificata e continua all'indietro verso l'inizio della stringa. Un parametro specifica il tipo di confronto da effettuare durante la ricerca della stringa specificata.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreLastIndexOf(String, Int32, Int32, StringComparison)Restituisce l'indice in base zero dell'ultima occorrenza di una stringa specificata all'interno di questa istanza. La ricerca inizia in una posizione del carattere specificata e continua all'indietro verso l'inizio della stringa per il numero determinato di posizioni dei caratteri. Un parametro specifica il tipo di confronto da effettuare durante la ricerca della stringa specificata.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreLastIndexOfAny(Char[])Restituisce la posizione di indice in base zero dell'ultima occorrenza in questa istanza di uno o più caratteri specificati in una matrice di caratteri Unicode.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreLastIndexOfAny(Char[], Int32)Restituisce la posizione di indice in base zero dell'ultima occorrenza in questa istanza di uno o più caratteri specificati in una matrice di caratteri Unicode. La ricerca inizia in corrispondenza di una posizione di carattere specificata e continua all'indietro verso l'inizio della stringa.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreLastIndexOfAny(Char[], Int32, Int32)Restituisce la posizione di indice in base zero dell'ultima occorrenza in questa istanza di uno o più caratteri specificati in una matrice di caratteri Unicode. La ricerca inizia in una posizione di carattere specificata e continua indietro verso l'inizio della stringa per un determinato numero di posizioni dei caratteri.
Metodo pubblicoNormalize()Restituisce una nuova stringa il cui valore testuale è lo stesso di questa stringa ma la cui rappresentazione binaria è nel formato di normalizzazione Unicode C.
Metodo pubblicoNormalize(NormalizationForm)Restituisce una nuova stringa il cui valore testuale è lo stesso di questa stringa ma la cui rappresentazione binaria è nel formato di normalizzazione Unicode specificato.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StorePadLeft(Int32)Restituisce una nuova stringa che allinea a destra i caratteri in questa istanza mediante l'aggiunta a sinistra di un numero di spazi tale da ottenere la lunghezza totale specificata.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StorePadLeft(Int32, Char)Restituisce una nuova stringa che allinea a destra i caratteri in questa istanza mediante l'aggiunta a sinistra di una sequenza di elementi pari al carattere Unicode specificato, in modo da ottenere la lunghezza totale specificata.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StorePadRight(Int32)Restituisce una nuova stringa che allinea a sinistra i caratteri in questa stringa mediante l'aggiunta a destra di un numero di spazi tale da ottenere la lunghezza totale specificata.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StorePadRight(Int32, Char)Restituisce una nuova stringa che allinea a sinistra i caratteri in questa stringa mediante l'aggiunta a destra di una sequenza di elementi pari al carattere Unicode specificato, in modo da ottenere la lunghezza totale specificata.
Metodo pubblicoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreRemove(Int32)Restituisce una nuova stringa in cui sono stati eliminati tutti i caratteri nell'istanza corrente a partire da una posizione specificata fino all'ultima posizione.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreRemove(Int32, Int32)Restituisce una nuova stringa in cui è stato eliminato un numero specificato di caratteri nell'istanza corrente a partire da una posizione specificata.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreReplace(Char, Char)Restituisce una nuova stringa in cui tutte le occorrenze di un carattere Unicode specificato presenti in questa istanza vengono sostituite con un altro carattere Unicode specificato.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreReplace(String, String)Restituisce una nuova stringa in cui tutte le occorrenze di una stringa specificata nell'istanza corrente vengono sostituite con un'altra stringa specificata.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreSplit(Char[])Restituisce una matrice di stringhe contenente le sottostringhe di questa istanza delimitate dagli elementi di una matrice di caratteri Unicode specificata.
Metodo pubblicoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreSplit(Char[], Int32)Restituisce una matrice di stringhe contenente le sottostringhe di questa istanza delimitate dagli elementi di una matrice di caratteri Unicode specificata. Un parametro consente di specificare il numero massimo di sottostringhe da restituire.
Metodo pubblicoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreSplit(Char[], StringSplitOptions)Restituisce una matrice di stringhe contenente le sottostringhe di questa stringa delimitate dagli elementi di una matrice di caratteri Unicode specificata. È disponibile un parametro che specifica se restituire gli elementi vuoti di una matrice.
Metodo pubblicoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreSplit(String[], StringSplitOptions)Restituisce una matrice di stringhe contenente le sottostringhe di questa stringa delimitate dagli elementi di una matrice di stringhe specificata. È disponibile un parametro che specifica se restituire gli elementi vuoti di una matrice.
Metodo pubblicoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreSplit(Char[], Int32, StringSplitOptions)Restituisce una matrice di stringhe contenente le sottostringhe di questa stringa delimitate dagli elementi di una matrice di caratteri Unicode specificata. Sono disponibili dei parametri per specificare il numero massimo di sottostringhe da restituire e se restituire elementi di matrice vuoti.
Metodo pubblicoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreSplit(String[], Int32, StringSplitOptions)Restituisce una matrice di stringhe contenente le sottostringhe di questa stringa delimitate dagli elementi di una matrice di stringhe specificata. Sono disponibili dei parametri per specificare il numero massimo di sottostringhe da restituire e se restituire elementi di matrice vuoti.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreStartsWith(String)Determina se l'inizio di questa istanza di stringa corrisponde alla stringa specificata.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreStartsWith(String, StringComparison)Consente di determinare se l'inizio di questa istanza di stringa corrisponde alla stringa specificata se confrontata utilizzando l'opzione di confronto specificata.
Metodo pubblicoStartsWith(String, Boolean, CultureInfo)Consente di determinare se l'inizio di questa istanza di stringa corrisponde alla stringa specificata se confrontata utilizzando le impostazioni cultura specificate.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreSubstring(Int32)Consente di recuperare una sottostringa da questa istanza. La sottostringa inizia in corrispondenza di un carattere specificato e continua fino alla fine della stringa.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreSubstring(Int32, Int32)Consente di recuperare una sottostringa da questa istanza. La sottostringa ha inizio alla posizione del carattere specificata e ha una determinata lunghezza.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreToCharArray()Consente di copiare i caratteri di questa istanza in una matrice di caratteri Unicode.
Metodo pubblicoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreToCharArray(Int32, Int32)Consente di copiare i caratteri di una determinata sottostringa di questa istanza in una matrice di caratteri Unicode.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreToLower()Restituisce una copia di questa stringa convertita in caratteri minuscoli.
Metodo pubblicoSupportato da XNA FrameworkToLower(CultureInfo)Restituisce una copia di questa stringa convertita in caratteri minuscoli, utilizzando le regole relative all'utilizzo di maiuscole e minuscole proprie delle impostazioni cultura specificate.
Metodo pubblicoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreToLowerInvariantRestituisce una copia dell'oggetto String convertito in caratteri minuscoli, utilizzando le regole relative all'utilizzo di maiuscole e minuscole proprie delle impostazioni cultura invarianti.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreToString()Restituisce questa istanza di String; di fatto, non viene eseguita alcuna conversione. (Esegue l'override di Object.ToString()).
Metodo pubblicoSupportato da XNA FrameworkToString(IFormatProvider)Restituisce questa istanza di String; di fatto, non viene eseguita alcuna conversione.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreToUpper()Restituisce una copia di questa stringa convertita in caratteri maiuscoli.
Metodo pubblicoSupportato da XNA FrameworkToUpper(CultureInfo)Restituisce una copia di questa stringa convertita in caratteri maiuscoli, utilizzando le regole relative all'utilizzo di maiuscole e minuscole proprie delle impostazioni cultura specificate.
Metodo pubblicoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreToUpperInvariantRestituisce una copia dell'oggetto String convertito in caratteri maiuscoli, utilizzando le regole relative all'utilizzo di maiuscole e minuscole proprie delle impostazioni cultura invarianti.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreTrim()Rimuove tutti gli spazi vuoti iniziali e finali dall'oggetto String corrente.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreTrim(Char[])Rimuove dall'oggetto String corrente tutte le occorrenze iniziali e finali di un set di caratteri specificati in una matrice.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreTrimEndRimuove dall'oggetto String corrente tutte le occorrenze finali di un set di caratteri specificati in una matrice.
Metodo pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreTrimStartRimuove dall'oggetto String corrente tutte le occorrenze iniziali di un set di caratteri specificati in una matrice.
In alto

  NomeDescrizione
Operatore pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreEqualityConsente di determinare se due stringhe specificate hanno lo stesso valore.
Operatore pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreInequalityDetermina se due stringhe specificate presentano valori diversi.
In alto

  NomeDescrizione
Metodo di estensione pubblicoSupportato da XNA FrameworkAggregate<Char>(Func<Char, Char, Char>)Sottoposto a overload. Applica una funzione accumulatore a una sequenza. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkAggregate<Char, TAccumulate>(TAccumulate, Func<TAccumulate, Char, TAccumulate>)Sottoposto a overload. Applica una funzione accumulatore a una sequenza. Il valore di inizializzazione specificato viene utilizzato come valore iniziale dell'accumulatore. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkAggregate<Char, TAccumulate, TResult>(TAccumulate, Func<TAccumulate, Char, TAccumulate>, Func<TAccumulate, TResult>)Sottoposto a overload. Applica una funzione accumulatore a una sequenza. Il valore di inizializzazione specificato viene utilizzato come valore iniziale dell'accumulatore e la funzione specificata viene utilizzata per selezionare il valore risultante. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkAll<Char>Determina se tutti gli elementi di una sequenza soddisfano una condizione. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkAny<Char>()Sottoposto a overload. Determina se una sequenza contiene elementi. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkAny<Char>(Func<Char, Boolean>)Sottoposto a overload. Determina se un qualsiasi elemento di una sequenza soddisfa una condizione. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkAsEnumerable<Char>Restituisce l'input digitato come oggetto IEnumerable<T>. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreAsParallel()Sottoposto a overload. Consente la parallelizzazione di una query. (Definito da ParallelEnumerable).
Metodo di estensione pubblicoAsParallel<Char>()Sottoposto a overload. Consente la parallelizzazione di una query. (Definito da ParallelEnumerable).
Metodo di estensione pubblicoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreAsQueryable()Sottoposto a overload. Converte un oggetto IEnumerable in un oggetto IQueryable. (Definito da Queryable).
Metodo di estensione pubblicoAsQueryable<Char>()Sottoposto a overload. Converte un generico oggetto IEnumerable<T> in un generico oggetto IQueryable<T>. (Definito da Queryable).
Metodo di estensione pubblicoSupportato da XNA FrameworkAverage<Char>(Func<Char, Int32>)Sottoposto a overload. Calcola la media di una sequenza di valori Int32 ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkAverage<Char>(Func<Char, Nullable<Int32>>)Sottoposto a overload. Calcola la media di una sequenza di valori Int32 nullable ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkAverage<Char>(Func<Char, Int64>)Sottoposto a overload. Calcola la media di una sequenza di valori Int64 ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkAverage<Char>(Func<Char, Nullable<Int64>>)Sottoposto a overload. Calcola la media di una sequenza di valori Int64 nullable ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkAverage<Char>(Func<Char, Single>)Sottoposto a overload. Calcola la media di una sequenza di valori Single ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkAverage<Char>(Func<Char, Nullable<Single>>)Sottoposto a overload. Calcola la media di una sequenza di valori Single nullable ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkAverage<Char>(Func<Char, Double>)Sottoposto a overload. Calcola la media di una sequenza di valori Double ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkAverage<Char>(Func<Char, Nullable<Double>>)Sottoposto a overload. Calcola la media di una sequenza di valori Double nullable ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkAverage<Char>(Func<Char, Decimal>)Sottoposto a overload. Calcola la media di una sequenza di valori Decimal ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkAverage<Char>(Func<Char, Nullable<Decimal>>)Sottoposto a overload. Calcola la media di una sequenza di valori Decimal nullable ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreCast<TResult>Esegue il cast degli elementi di un oggetto IEnumerable nel tipo specificato. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkConcat<Char>Concatena due sequenze. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkContains<Char>(Char)Sottoposto a overload. Determina se una sequenza contiene uno specifico elemento utilizzando l'operatore di confronto di uguaglianza predefinito. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkContains<Char>(Char, IEqualityComparer<Char>)Sottoposto a overload. Determina se una sequenza contiene un elemento specificato utilizzando un oggetto IEqualityComparer<T> specificato. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkCount<Char>()Sottoposto a overload. Restituisce il numero di elementi in una sequenza. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkCount<Char>(Func<Char, Boolean>)Sottoposto a overload. Restituisce un valore che rappresenta il numero di elementi nella sequenza specificata che soddisfano una condizione. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkDefaultIfEmpty<Char>()Sottoposto a overload. Restituisce gli elementi della sequenza specificata o il valore predefinito del parametro di tipo in una raccolta di singleton se la sequenza è vuota. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkDefaultIfEmpty<Char>(Char)Sottoposto a overload. Restituisce gli elementi della sequenza specificata o il valore specificato in una raccolta di singleton se la sequenza è vuota. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkDistinct<Char>()Sottoposto a overload. Restituisce elementi distinti da una sequenza utilizzando l'operatore di confronto di uguaglianza predefinito per confrontare i valori. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkDistinct<Char>(IEqualityComparer<Char>)Sottoposto a overload. Restituisce elementi distinti da una sequenza utilizzando uno specificato IEqualityComparer<T> per confrontare valori. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkElementAt<Char>Restituisce l'elemento in corrispondenza dell’indice specificato in una sequenza. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkElementAtOrDefault<Char>Restituisce l'elemento in corrispondenza di un indice specificato in una sequenza o un valore predefinito se l'indice è esterno all'intervallo. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkExcept<Char>(IEnumerable<Char>)Sottoposto a overload. Produce la differenza insiemistica di due sequenze utilizzando l'operatore di confronto di uguaglianza predefinito per confrontare i valori. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkExcept<Char>(IEnumerable<Char>, IEqualityComparer<Char>)Sottoposto a overload. Produce la differenza insiemistica delle due sequenze utilizzando l’oggetto IEqualityComparer<T> specificato per confrontare i valori. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkFirst<Char>()Sottoposto a overload. Restituisce il primo elemento di una sequenza. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkFirst<Char>(Func<Char, Boolean>)Sottoposto a overload. Restituisce il primo elemento in una sequenza che soddisfa una condizione specificata. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkFirstOrDefault<Char>()Sottoposto a overload. Restituisce il primo elemento di una sequenza o un valore predefinito se la sequenza non contiene elementi. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkFirstOrDefault<Char>(Func<Char, Boolean>)Sottoposto a overload. Restituisce il primo elemento della sequenza che soddisfa una condizione specificata o un valore predefinito se un tale elemento non viene trovato. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkGroupBy<Char, TKey>(Func<Char, TKey>)Sottoposto a overload. Raggruppa gli elementi di una sequenza secondo una specificata funzione del selettore principale. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkGroupBy<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)Sottoposto a overload. Raggruppa gli elementi di una sequenza secondo una specificata funzione del selettore principale e confronta le chiavi utilizzando un operatore di confronto specificato. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkGroupBy<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)Sottoposto a overload. Raggruppa gli elementi di una sequenza in base a una funzione specificata del selettore principale e proietta gli elementi di ogni gruppo utilizzando una funzione specificata. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkGroupBy<Char, TKey, TResult>(Func<Char, TKey>, Func<TKey, IEnumerable<Char>, TResult>)Sottoposto a overload. Raggruppa gli elementi di una sequenza in base a una funzione del selettore principale specificata e crea un valore risultante da ciascun gruppo e relativa chiave. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkGroupBy<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)Sottoposto a overload. Raggruppa gli elementi di una sequenza secondo una specificata funzione del selettore principale. Le chiavi vengono confrontate utilizzando un operatore di confronto e gli elementi di ogni gruppo vengono proiettati utilizzando una funzione specificata. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkGroupBy<Char, TKey, TResult>(Func<Char, TKey>, Func<TKey, IEnumerable<Char>, TResult>, IEqualityComparer<TKey>)Sottoposto a overload. Raggruppa gli elementi di una sequenza in base a una funzione del selettore principale specificata e crea un valore risultante da ciascun gruppo e relativa chiave. Le chiavi vengono confrontate utilizzando un operatore di confronto specificato. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkGroupBy<Char, TKey, TElement, TResult>(Func<Char, TKey>, Func<Char, TElement>, Func<TKey, IEnumerable<TElement>, TResult>)Sottoposto a overload. Raggruppa gli elementi di una sequenza in base a una funzione del selettore principale specificata e crea un valore risultante da ciascun gruppo e relativa chiave. Gli elementi di ogni gruppo vengono proiettati utilizzando una funzione specificata. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkGroupBy<Char, TKey, TElement, TResult>(Func<Char, TKey>, Func<Char, TElement>, Func<TKey, IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)Sottoposto a overload. Raggruppa gli elementi di una sequenza in base a una funzione del selettore principale specificata e crea un valore risultante da ciascun gruppo e relativa chiave. I valori delle chiavi vengono confrontati utilizzando un operatore di confronto specificato e gli elementi di ogni gruppo vengono proiettati utilizzando una funzione specificata. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkGroupJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, IEnumerable<TInner>, TResult>)Sottoposto a overload. Correla gli elementi di due sequenze in base all'uguaglianza delle chiavi e raggruppa i risultati. Per confrontare le chiavi viene utilizzato l'operatore di confronto di uguaglianza predefinito. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkGroupJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)Sottoposto a overload. Correla gli elementi di due sequenze in base all'uguaglianza delle chiavi e raggruppa i risultati. Viene utilizzato un oggetto IEqualityComparer<T> specificato per confrontare le chiavi. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkIntersect<Char>(IEnumerable<Char>)Sottoposto a overload. Produce l’intersezione insiemistica di due sequenze utilizzando l'operatore di confronto uguaglianze predefinito per confrontare i valori. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkIntersect<Char>(IEnumerable<Char>, IEqualityComparer<Char>)Sottoposto a overload. Produce l’intersezione insiemistica delle due sequenze utilizzando l’oggetto IEqualityComparer<T> specificato per confrontare i valori. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, TInner, TResult>)Sottoposto a overload. Correla gli elementi di due sequenze in base alle chiavi corrispondenti. Per confrontare le chiavi viene utilizzato l'operatore di confronto di uguaglianza predefinito. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, TInner, TResult>, IEqualityComparer<TKey>)Sottoposto a overload. Correla gli elementi di due sequenze in base alle chiavi corrispondenti. Viene utilizzato un oggetto IEqualityComparer<T> specificato per confrontare le chiavi. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkLast<Char>()Sottoposto a overload. Restituisce l'ultimo elemento di una sequenza. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkLast<Char>(Func<Char, Boolean>)Sottoposto a overload. Restituisce l’ultimo elemento di una sequenza che soddisfa una condizione specificata. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkLastOrDefault<Char>()Sottoposto a overload. Restituisce l’ultimo elemento di una sequenza o un valore predefinito se la sequenza non contiene elementi. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkLastOrDefault<Char>(Func<Char, Boolean>)Sottoposto a overload. Restituisce l’ultimo elemento di una sequenza che soddisfa una condizione specificata o un valore predefinito se un tale elemento non viene trovato. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkLongCount<Char>()Sottoposto a overload. Restituisce un oggetto Int64 che rappresenta il numero totale di elementi in una sequenza. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkLongCount<Char>(Func<Char, Boolean>)Sottoposto a overload. Restituisce un oggetto Int64 che rappresenta quanti elementi in una sequenza soddisfano una condizione. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMax<Char>()Sottoposto a overload. Restituisce il valore massimo in una sequenza generica. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMax<Char>(Func<Char, Int32>)Sottoposto a overload. Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore Int32 massimo. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMax<Char>(Func<Char, Nullable<Int32>>)Sottoposto a overload. Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore nullable Int32 massimo. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMax<Char>(Func<Char, Int64>)Sottoposto a overload. Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore Int64 massimo. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMax<Char>(Func<Char, Nullable<Int64>>)Sottoposto a overload. Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore nullable Int64 massimo. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMax<Char>(Func<Char, Single>)Sottoposto a overload. Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore Single massimo. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMax<Char>(Func<Char, Nullable<Single>>)Sottoposto a overload. Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore nullable Single massimo. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMax<Char>(Func<Char, Double>)Sottoposto a overload. Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore Double massimo. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMax<Char>(Func<Char, Nullable<Double>>)Sottoposto a overload. Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore nullable Double massimo. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMax<Char>(Func<Char, Decimal>)Sottoposto a overload. Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore Decimal massimo. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMax<Char>(Func<Char, Nullable<Decimal>>)Sottoposto a overload. Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore nullable Decimal massimo. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMax<Char, TResult>(Func<Char, TResult>)Sottoposto a overload. Richiama una funzione di trasformazione su ogni elemento di una generica sequenza e restituisce il valore massimo risultante. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMin<Char>()Sottoposto a overload. Restituisce il valore minimo in una sequenza generica. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMin<Char>(Func<Char, Int32>)Sottoposto a overload. Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore Int32 minimo. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMin<Char>(Func<Char, Nullable<Int32>>)Sottoposto a overload. Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore nullable Int32 minimo. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMin<Char>(Func<Char, Int64>)Sottoposto a overload. Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore Int64 minimo. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMin<Char>(Func<Char, Nullable<Int64>>)Sottoposto a overload. Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore nullable Int64 minimo. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMin<Char>(Func<Char, Single>)Sottoposto a overload. Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore Single minimo. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMin<Char>(Func<Char, Nullable<Single>>)Sottoposto a overload. Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore nullable Single minimo. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMin<Char>(Func<Char, Double>)Sottoposto a overload. Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore Double minimo. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMin<Char>(Func<Char, Nullable<Double>>)Sottoposto a overload. Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore nullable Double minimo. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMin<Char>(Func<Char, Decimal>)Sottoposto a overload. Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore Decimal minimo. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMin<Char>(Func<Char, Nullable<Decimal>>)Sottoposto a overload. Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore nullable Decimal minimo. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkMin<Char, TResult>(Func<Char, TResult>)Sottoposto a overload. Richiama una funzione di trasformazione su ogni elemento di una generica sequenza e restituisce il valore minimo risultante. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreOfType<TResult>Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkOrderBy<Char, TKey>(Func<Char, TKey>)Sottoposto a overload. Ordina in senso crescente gli elementi di una sequenza secondo una chiave. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkOrderBy<Char, TKey>(Func<Char, TKey>, IComparer<TKey>)Sottoposto a overload. Ordina in ordine crescente gli elementi di una sequenza utilizzando un operatore di confronto specificato. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkOrderByDescending<Char, TKey>(Func<Char, TKey>)Sottoposto a overload. Ordina in senso decrescente gli elementi di una sequenza secondo una chiave. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkOrderByDescending<Char, TKey>(Func<Char, TKey>, IComparer<TKey>)Sottoposto a overload. Ordina in senso decrescente gli elementi di una sequenza utilizzando un operatore di confronto specificato. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkReverse<Char>Inverte l'ordine degli elementi in una sequenza. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSelect<Char, TResult>(Func<Char, TResult>)Sottoposto a overload. Proietta ogni elemento di una sequenza in una nuova maschera. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSelect<Char, TResult>(Func<Char, Int32, TResult>)Sottoposto a overload. Proietta ogni elemento di una sequenza in un nuovo modulo incorporando l'indice dell'elemento. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSelectMany<Char, TResult>(Func<Char, IEnumerable<TResult>>)Sottoposto a overload. Proietta ogni elemento di una sequenza a un oggetto IEnumerable<T> e semplifica le sequenze risultanti in un’unica sequenza. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSelectMany<Char, TResult>(Func<Char, Int32, IEnumerable<TResult>>)Sottoposto a overload. Proietta ogni elemento di una sequenza a un oggetto IEnumerable<T> e semplifica le sequenze risultanti in un’unica sequenza. L'indice di ogni elemento di origine viene utilizzato nella maschera proiettata di tale elemento. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSelectMany<Char, TCollection, TResult>(Func<Char, Int32, IEnumerable<TCollection>>, Func<Char, TCollection, TResult>)Sottoposto a overload. Proietta ogni elemento di una sequenza a un oggetto IEnumerable<T>, semplifica le sequenze risultanti in un’unica sequenza e richiama una funzione del selettore di risultato su ogni elemento al suo interno. L'indice di ogni elemento di origine viene utilizzato nella maschera intermedia proiettata di tale elemento. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSelectMany<Char, TCollection, TResult>(Func<Char, IEnumerable<TCollection>>, Func<Char, TCollection, TResult>)Sottoposto a overload. Proietta ogni elemento di una sequenza a un oggetto IEnumerable<T>, semplifica le sequenze risultanti in un’unica sequenza e richiama una funzione del selettore di risultato su ogni elemento al suo interno. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSequenceEqual<Char>(IEnumerable<Char>)Sottoposto a overload. Determina se due sequenze sono uguali confrontando gli elementi tramite l’uso dell'operatore di confronto di uguaglianza predefinito per il loro tipo. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSequenceEqual<Char>(IEnumerable<Char>, IEqualityComparer<Char>)Sottoposto a overload. Determina se due sequenze sono uguali confrontando i loro elementi mediante l’uso di un oggetto IEqualityComparer<T> specificato. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSingle<Char>()Sottoposto a overload. Restituisce il singolo elemento di una sequenza e genera un'eccezione se nella sequenza non è presente esattamente un elemento. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSingle<Char>(Func<Char, Boolean>)Sottoposto a overload. Restituisce il singolo elemento di una sequenza che soddisfa una condizione specificata e genera un'eccezione se esiste più di un elemento. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSingleOrDefault<Char>()Sottoposto a overload. Restituisce il singolo elemento di una sequenza o un valore predefinito se la sequenza è vuota. Questo metodo genera un'eccezione se esiste più di un elemento nella sequenza. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSingleOrDefault<Char>(Func<Char, Boolean>)Sottoposto a overload. Restituisce il singolo elemento di una sequenza che soddisfa una condizione specificata o un valore predefinito se tale elemento esiste. Questo metodo genera un'eccezione se più di un elemento soddisfa la condizione. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSkip<Char>Ignora un numero specificato di elementi in una sequenza e quindi restituisce gli elementi rimanenti. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSkipWhile<Char>(Func<Char, Boolean>)Sottoposto a overload. Ignora gli elementi in sequenza finché la condizione specificata è soddisfatta e quindi restituisce gli elementi rimanenti. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSkipWhile<Char>(Func<Char, Int32, Boolean>)Sottoposto a overload. Ignora gli elementi in sequenza finché la condizione specificata è soddisfatta e quindi restituisce gli elementi rimanenti. L'indice dell'elemento viene utilizzato nella logica della funzione predicativa. (Definito da Enumerable).
Metodo di estensione pubblicoSubscribe<Char>(IObserver<Char>)Sottoposto a overload. (Definito da Observable).
Metodo di estensione pubblicoSubscribe<Char>(IObserver<Char>, IScheduler)Sottoposto a overload. (Definito da Observable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSum<Char>(Func<Char, Int32>)Sottoposto a overload. Calcola la somma della sequenza di valori Int32 ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSum<Char>(Func<Char, Nullable<Int32>>)Sottoposto a overload. Calcola la somma della sequenza di valori Int32 nullable, ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSum<Char>(Func<Char, Int64>)Sottoposto a overload. Calcola la somma della sequenza di valori Int64 ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSum<Char>(Func<Char, Nullable<Int64>>)Sottoposto a overload. Calcola la somma della sequenza di valori Int64 nullable, ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSum<Char>(Func<Char, Single>)Sottoposto a overload. Calcola la somma della sequenza di valori Single ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSum<Char>(Func<Char, Nullable<Single>>)Sottoposto a overload. Calcola la somma della sequenza di valori Single nullable, ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSum<Char>(Func<Char, Double>)Sottoposto a overload. Calcola la somma della sequenza di valori Double ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSum<Char>(Func<Char, Nullable<Double>>)Sottoposto a overload. Calcola la somma della sequenza di valori Double nullable, ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSum<Char>(Func<Char, Decimal>)Sottoposto a overload. Calcola la somma della sequenza di valori Decimal ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkSum<Char>(Func<Char, Nullable<Decimal>>)Sottoposto a overload. Calcola la somma della sequenza di valori Decimal nullable, ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkTake<Char>Restituisce un numero specificato di elementi contigui dall'inizio di una sequenza. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkTakeWhile<Char>(Func<Char, Boolean>)Sottoposto a overload. Restituisce elementi di una sequenza finché una condizione specificata è soddisfatta. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkTakeWhile<Char>(Func<Char, Int32, Boolean>)Sottoposto a overload. Restituisce elementi di una sequenza finché una condizione specificata è soddisfatta. L'indice dell'elemento viene utilizzato nella logica della funzione predicativa. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkToArray<Char>Crea una matrice da un oggetto IEnumerable<T>. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkToDictionary<Char, TKey>(Func<Char, TKey>)Sottoposto a overload. Crea un oggetto Dictionary<TKey, TValue> da un oggetto IEnumerable<T> secondo una funzione del selettore principale specificata. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkToDictionary<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)Sottoposto a overload. Crea un oggetto Dictionary<TKey, TValue> da un oggetto IEnumerable<T> secondo una funzione del selettore principale specificata e un operatore di confronto principale. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkToDictionary<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)Sottoposto a overload. Crea un oggetto Dictionary<TKey, TValue> da un oggetto IEnumerable<T> secondo le funzioni specificate del selettore principale e del selettore di elementi. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkToDictionary<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)Sottoposto a overload. Crea un oggetto Dictionary<TKey, TValue> da un oggetto IEnumerable<T> secondo una funzione specificata del selettore principale, un operatore di confronto principale e una funzione del selettore di elementi. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkToList<Char>Crea un oggetto List<T> da un oggetto IEnumerable<T>. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkToLookup<Char, TKey>(Func<Char, TKey>)Sottoposto a overload. Crea un oggetto Lookup<TKey, TElement> da un oggetto IEnumerable<T> secondo una funzione del selettore principale specificata. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkToLookup<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)Sottoposto a overload. Crea un oggetto Lookup<TKey, TElement> da un oggetto IEnumerable<T> secondo una funzione del selettore principale specificata e un operatore di confronto principale. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkToLookup<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)Sottoposto a overload. Crea un oggetto Lookup<TKey, TElement> da un oggetto IEnumerable<T> secondo le funzioni specificate del selettore principale e del selettore di elementi. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkToLookup<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)Sottoposto a overload. Crea un oggetto Lookup<TKey, TElement> da un oggetto IEnumerable<T> secondo una funzione specificata del selettore principale, un operatore di confronto principale e una funzione del selettore di elementi. (Definito da Enumerable).
Metodo di estensione pubblicoToObservable<Char>()Sottoposto a overload. (Definito da Observable).
Metodo di estensione pubblicoToObservable<Char>(IScheduler)Sottoposto a overload. (Definito da Observable).
Metodo di estensione pubblicoSupportato da XNA FrameworkUnion<Char>(IEnumerable<Char>)Sottoposto a overload. Produce l'unione insiemistica delle due sequenze utilizzando l'operatore di confronto di uguaglianza predefinito. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkUnion<Char>(IEnumerable<Char>, IEqualityComparer<Char>)Sottoposto a overload. Produce l'unione insiemistica di due sequenze utilizzando un oggetto IEqualityComparer<T> specificato. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkWhere<Char>(Func<Char, Boolean>)Sottoposto a overload. Filtra una sequenza di valori in base a un predicato. (Definito da Enumerable).
Metodo di estensione pubblicoSupportato da XNA FrameworkWhere<Char>(Func<Char, Int32, Boolean>)Sottoposto a overload. Filtra una sequenza di valori in base a un predicato. L'indice di ogni elemento viene utilizzato nella logica della funzione del predicato. (Definito da Enumerable).
Metodo di estensione pubblicoZip<Char, TSecond, TResult>Applica una funzione specificata agli elementi corrispondenti di due sequenze, producendo una sequenza dei risultati. (Definito da Enumerable).
In alto

  NomeDescrizione
Campo pubblicoMembro staticoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreEmptyRappresenta la stringa vuota. Questo è un campo di sola lettura.
In alto

  NomeDescrizione
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreIComparable.CompareToConfronta l'istanza corrente a un altro oggetto dello stesso tipo e restituisce un Integer che indica se l'istanza corrente precede, segue o si trova nella stessa posizione dell'altro oggetto all'interno dell'ordinamento.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToBooleanInfrastruttura. Per una descrizione di questo membro, vedere ToBoolean.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToByteInfrastruttura. Per una descrizione di questo membro, vedere ToByte.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToCharInfrastruttura. Per una descrizione di questo membro, vedere ToChar.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToDateTimeInfrastruttura. Per una descrizione di questo membro, vedere ToDateTime.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToDecimalInfrastruttura. Per una descrizione di questo membro, vedere ToDecimal.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToDoubleInfrastruttura. Per una descrizione di questo membro, vedere ToDouble.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToInt16Infrastruttura. Per una descrizione di questo membro, vedere ToInt16.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToInt32Infrastruttura. Per una descrizione di questo membro, vedere ToInt32.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToInt64Infrastruttura. Per una descrizione di questo membro, vedere ToInt64.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToSByteInfrastruttura. Per una descrizione di questo membro, vedere ToSByte.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToSingleInfrastruttura. Per una descrizione di questo membro, vedere ToSingle.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToTypeInfrastruttura. Per una descrizione di questo membro, vedere ToType.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToUInt16Infrastruttura. Per una descrizione di questo membro, vedere ToUInt16.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToUInt32Infrastruttura. Per una descrizione di questo membro, vedere il metodo ToUInt32.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIConvertible.ToUInt64Infrastruttura. Per una descrizione di questo membro, vedere il metodo ToUInt64.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkIEnumerable<Char>.GetEnumeratorRestituisce un enumeratore che consente di scorrere l'oggetto String corrente.
Implementazione esplicita dell'interfacciaMetodo privatoSupportato da XNA FrameworkSupportato da Libreria di classi portabileSupportato in .NET per applicazioni Windows StoreIEnumerable.GetEnumeratorRestituisce un enumeratore che consente di scorrere l'oggetto String corrente.
In alto

Una stringa è una raccolta sequenziale di caratteri Unicode, tipicamente utilizzata per rappresentare testo. Un oggetto String è una raccolta sequenziale di oggetti System.Char che rappresentano una stringa. Il valore dell'oggetto String è dato dal contenuto dell'insieme sequenziale e non è modificabile, ossia è di sola lettura. Per ulteriori informazioni sull'immutabilità delle stringhe, consultare la sezione seguente Immutabilità e la classe StringBuilder in questo argomento. La dimensione massima di un oggetto in memoria String è 2 GB, o 1 miliardo di caratteri.

Contenuto della sezione:

Creazione di un'istanza di un oggetto String
Oggetti char e caratteri Unicode
Stringhe e caratteri null incorporati
Stringhe e indici
Stringhe null e stringhe vuote
Immutabilità e la classe StringBuilder
Ordinale per le operazioni dipendenti dalle impostazioni cultura
Normalizzazione
Operazioni su stringhe per categoria

Creazione di un'istanza di un oggetto String

È possibile creare un'istanza di un oggetto String in una delle modalità riportate di seguito.

  • Assegnando un valore letterale stringa a una variabile String. Si tratta del metodo più utilizzato per la creazione di una stringa. Nell'esempio riportato di seguito viene utilizzata un'assegnazione per creare diverse stringhe. Si noti che in C#, poiché la barra rovesciata (\) è un carattere di escape, a barre rovesciate letterali in una stringa devono essere applicati caratteri di escape o la stringa intera deve essere racchiusa tra caratteri @.

    
    string string1 = "This is a string created by assignment.";
    Console.WriteLine(string1);
    string string2a = "The path is C:\\PublicDocuments\\Report1.doc";
    Console.WriteLine(string2a);
    string string2b = @"The path is C:\PublicDocuments\Report1.doc";
    Console.WriteLine(string2b);
    // The example displays the following output:
    //       This is a string created by assignment.
    //       The path is C:\PublicDocuments\Report1.doc
    //       The path is C:\PublicDocuments\Report1.doc      
    
    
    
  • Chiamando un costruttore di classe String. Nell'esempio seguente viene creata un'istanza di stringhe tramite la chiamata a diversi costruttori di classe. Si noti che alcuni costruttori includono puntatori a matrici di caratteri o a matrici di byte con segno come parametri. Visual Basic non supporta le chiamate a questi costruttori. Per informazioni dettagliate sui costruttori String, consultare il riepilogo del costruttore String.

    
    char[] chars = { 'w', 'o', 'r', 'd' };
    sbyte[] bytes = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };
    
    // Create a string from a character array.
    string string1 = new string(chars);
    Console.WriteLine(string1);
    
    // Create a string that consists of a character repeated 20 times.
    string string2 = new string('c', 20);
    Console.WriteLine(string2);
    
    string stringFromBytes = null;
    string stringFromChars = null;
    unsafe
    {
       fixed (sbyte* pbytes = bytes)
       {
          // Create a string from a pointer to a signed byte array.
          stringFromBytes = new string(pbytes);
       }
       fixed (char* pchars = chars)
       {
          // Create a string from a pointer to a character array.
          stringFromChars = new string(pchars);
       }
    }
    Console.WriteLine(stringFromBytes);
    Console.WriteLine(stringFromChars);
    // The example displays the following output:
    //       word
    //       cccccccccccccccccccc
    //       ABCDE
    //       word  
    
    
    
  • Tramite l'operatore di concatenazione di stringhe (+ in C# e & oppure + in Visual Basic) per creare una singola stringa da qualsiasi combinazione di istanze di String e di valori letterali stringa. Nell'esempio seguente viene illustrato l'utilizzo dell'operatore di concatenazione di stringhe.

    
    string string1 = "Today is " + DateTime.Now.ToString("D") + ".";
    Console.WriteLine(string1);
    
    string string2 = "This is one sentence. " + "This is a second. ";
    string2 += "This is a third sentence.";
    Console.WriteLine(string2);
    // The example displays output like the following:
    //    Today is Tuesday, July 06, 2011.
    //    This is one sentence. This is a second. This is a third sentence.
    
    
    
  • Recuperando una proprietà o chiamando un metodo che restituisce una stringa. Nell'esempio seguente vengono utilizzati i metodi della classe String per estrarre una sottostringa da una stringa più grande.

    
    string sentence = "This sentence has five words.";
    // Extract the second word.
    int startPosition = sentence.IndexOf(" ") + 1;
    string word2 = sentence.Substring(startPosition,
                                      sentence.IndexOf(" ", startPosition) - startPosition);
    Console.WriteLine("Second word: " + word2);
    // The example displays the following output:
    //       Second word: sentence
    
    
    
  • Chiamando un metodo di formattazione per convertire un valore o un oggetto alla relativa rappresentazione in formato stringa. Nell'esempio seguente viene utilizzata la funzionalità formattazione composita per incorporare la rappresentazione di stringa di due oggetti in una stringa.

    
    DateTime dateAndTime = new DateTime(2011, 7, 6, 7, 32, 0);
    double temperature = 68.3;
    string result = String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                  dateAndTime, temperature);
    Console.WriteLine(result);
    // The example displays the following output:
    //       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.      
    
    
    

Oggetti char e caratteri Unicode

Ciascun carattere di una stringa è definito da un valore scalare Unicode, definito anche punto di codice Unicode ovvero valore (numerico) ordinale del carattere Unicode. Tutti i punti di codice vengono codificati utilizzando la codifica UTF-16 e il valore numerico di ciascun elemento della codifica è rappresentato da un oggetto Char.

Un singolo oggetto Char solitamente rappresenta un singolo punto di codice, ovvero il valore numerico dell'oggetto Char equivale al punto di codice. Ad esempio, il punto di codice per il carattere "a" è U+0061. È tuttavia possibile che un punto di codice richieda più di un elemento codificato (più di un oggetto Char). Lo standard Unicode definisce tre tipi di caratteri che corrispondono a più oggetti Char: grafema, punti di codice supplementari Unicode e caratteri nei piani supplementari.

  • Un grafema è rappresentato da un carattere di base seguito da uno o più caratteri di combinazione. Il carattere ä, ad esempio, è rappresentato da un oggetto Char, il cui punto di codice è U+0061 seguito da un oggetto Char, il cui punto di codice è U+0308. Questo carattere può essere definito anche da un unico oggetto Char che dispone di un punto di codice di U+00E4. Come illustrato nell'esempio seguente, un confronto dipendente dalle impostazioni cultura per l'uguaglianza indica che queste due rappresentazioni sono uguali, a differenza di un confronto ordinale comune. Tuttavia, se le due stringhe vengono normalizzate, un confronto ordinale indica anche che sono uguali. (Per ulteriori informazioni sulla normalizzazione di stringhe, vedere la sezione Normalizzazione.)

    
    using System;
    using System.Globalization;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\graphemes.txt");
          string grapheme = "\u0061\u0308";
          sw.WriteLine(grapheme);
    
          string singleChar = "\u00e4";
          sw.WriteLine(singleChar);
    
          sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.CurrentCulture));
          sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.Ordinal));
          sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme.Normalize(), 
                                     singleChar.Normalize(), 
                                     StringComparison.Ordinal));
          sw.Close(); 
       }
    }
    // The example produces the following output:
    //       ä
    //       ä
    //       ä = ä (Culture-sensitive): True
    //       ä = ä (Ordinal): False
    //       ä = ä (Normalized Ordinal): True
    
    
    
  • Un punto di codice supplementare Unicode (una coppia di surrogati) viene rappresentato da un oggetto Char il cui punto di codice è un surrogato alto seguito da un oggetto Char il cui punto di codice è un surrogato basso. Le unità di codice dei surrogati alti vanno da U+D800 a U+DBFF. Le unità di codice dei surrogati bassi vanno da U+DC00 a U+DFFF. Le coppie di surrogati sono utilizzate per rappresentare caratteri nei piani supplementari Unicode 16. Nell'esempio seguente viene creato un carattere surrogato che viene passato al metodo Char.IsSurrogatePair(Char, Char) per determinare se è una coppia di surrogati.

    
    using System;
    
    public class Example
    {
       public static void Main()
       {
          string surrogate = "\uD800\uDC03";
          for (int ctr = 0; ctr < surrogate.Length; ctr++) 
             Console.Write("U+{0:X2} ", Convert.ToUInt16(surrogate[ctr]));
    
          Console.WriteLine();
          Console.WriteLine("   Is Surrogate Pair: {0}", 
                            Char.IsSurrogatePair(surrogate[0], surrogate[1]));
       }
    }
    // The example displays the following output:
    //       U+D800 U+DC03
    //          Is Surrogate Pair: True
    
    
    

Stringhe e caratteri null incorporati

In .NET Framework un oggetto String può includere valori Null incorporati che vengono conteggiati nella lunghezza della stringa. In alcuni linguaggi, ad esempio C e C++, tuttavia il carattere null indica la fine di una stringa, non è considerato parte della stringa e non viene conteggiato nella lunghezza della stringa. Vale a dire che i seguenti presupposti comuni per i programmatori che utilizzano i linguaggi C e C++ o le librerie scritte in questi linguaggi non sono necessariamente validi se applicati a oggetti String:

  • Il valore restituito dalla funzione strlen o wcslen non è necessariamente uguale a String.Length.

  • La stringa creata dalla funzione strcpy_s o wcscpy_s non è necessariamente identica alla stringa creata dal metodo String.Copy.

È necessario assicurare che il codice C e C++ nativo che crea istanze di oggetti String e il codice al quale vengono passati oggetti String tramite pInvoke non presupponga che la fine della stringa sia contrassegnata da un carattere null incorporato.

I caratteri Null incorporati in una stringa vengono inoltre trattati in modo diverso quando viene ordinata (o confrontata) una stringa e quando si eseguono ricerche in essa. I caratteri null vengono ignorati quando si eseguono confronti dipendenti dalle impostazioni cultura fra due stringhe, inclusi i confronti che utilizzano la lingua inglese. Sono considerati solo nel caso di confronti tra ordinali o tra ordinali senza distinzione tra maiuscole e minuscole. D'altra parte i caratteri null incorporati vengono sempre considerati in caso di ricerca di una stringa con metodi quali Contains, StartsWithe IndexOf.

Stringhe e indici

Un indice è la posizione di un oggetto Char, non di un carattere Unicode, in un oggetto String. Si tratta di un numero non negativo a base zero che parte dalla prima posizione della stringa, la posizione di indice zero. Un numero di metodi di ricerca, ad esempio IndexOf e LastIndexOf, restituire l'indice di un carattere o una sottostringa nell'istanza di stringa.

La proprietà Chars consente di accedere a singoli oggetti Char dalla posizione di indice nella stringa. Poiché la proprietà Chars è la proprietà predefinita (in Visual Basic) o l'indicizzatore (in C#), è possibile accedere agli oggetti Char singoli in una stringa tramite un codice analogo al seguente. Questo codice cerca caratteri di spazio vuoto o punteggiatura in una stringa per determinare quante parole sono contenute nella stringa.


using System;

public class Example
{
   public static void Main()
   {
      string s1 = "This string consists of a single short sentence.";
      int nWords = 0;

      s1 = s1.Trim();      
      for (int ctr = 0; ctr < s1.Length; ctr++) {
         if (Char.IsPunctuation(s1[ctr]) | Char.IsWhiteSpace(s1[ctr]))
            nWords++;              
      }
      Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                        s1, nWords);                                                                     
   }
}
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.


Poiché la classe String implementa l'interfaccia IEnumerable, è possibile scorrere anche gli oggetti Char in una stringa tramite un costrutto foreach, come mostra l'esempio seguente.


using System;

public class Example
{
   public static void Main()
   {
      string s1 = "This string consists of a single short sentence.";
      int nWords = 0;

      s1 = s1.Trim();      
      foreach (var ch in s1) {
         if (Char.IsPunctuation(ch) | Char.IsWhiteSpace(ch))
            nWords++;              
      }
      Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                        s1, nWords);                                                                     
   }
}
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.


Valori di indice consecutivi non corrispondono necessariamente a caratteri Unicode consecutivi, dal momento che un carattere Unicode può essere codificato in più di un oggetto Char. In particolare, una stringa può contenere le unità di testo multi-carattere che sono costituite da un carattere base seguito da uno o più caratteri di unione o dalle coppie di surrogati. Per utilizzare i caratteri Unicode anziché gli oggetti Char, utilizzare le classi System.Globalization.StringInfo e TextElementEnumerator. Nell'esempio seguente viene illustrata la differenza tra codice che funziona con oggetti Char e codice che funziona con caratteri Unicode. Confronta il numero di caratteri o elementi di testo in ogni parola di una frase. La stringa include due sequenze di un carattere di base seguito da un carattere di unione.


using System;
using System.Collections.Generic;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // First sentence of The Mystery of the Yellow Room, by Leroux.
      string opening = "Ce n'est pas sans une certaine émotion que "+
                       "je commence à raconter ici les aventures " +
                       "extraordinaires de Joseph Rouletabille."; 
      // Character counters.
      int nChars = 0;
      // Objects to store word count.
      List<int> chars = new List<int>();
      List<int> elements = new List<int>();

      foreach (var ch in opening) {
         // Skip the ' character.
         if (ch == '\u0027') continue;

         if (Char.IsWhiteSpace(ch) | (Char.IsPunctuation(ch))) {
            chars.Add(nChars);
            nChars = 0;
         }
         else {
            nChars++;
         }
      }

      TextElementEnumerator te = StringInfo.GetTextElementEnumerator(opening);
      while (te.MoveNext()) {
         string s = te.GetTextElement();   
         // Skip the ' character.
         if (s == "\u0027") continue;
         if ( String.IsNullOrEmpty(s.Trim()) | (s.Length == 1 && Char.IsPunctuation(Convert.ToChar(s)))) {
            elements.Add(nChars);         
            nChars = 0;
         }
         else {
            nChars++;
         }
      }

      // Display character counts.
      Console.WriteLine("{0,6} {1,20} {2,20}",
                        "Word #", "Char Objects", "Characters"); 
      for (int ctr = 0; ctr < chars.Count; ctr++) 
         Console.WriteLine("{0,6} {1,20} {2,20}",
                           ctr, chars[ctr], elements[ctr]); 
   }
}
// The example displays the following output:
//       Word #         Char Objects           Characters
//            0                    2                    2
//            1                    4                    4
//            2                    3                    3
//            3                    4                    4
//            4                    3                    3
//            5                    8                    8
//            6                    8                    7
//            7                    3                    3
//            8                    2                    2
//            9                    8                    8
//           10                    2                    1
//           11                    8                    8
//           12                    3                    3
//           13                    3                    3
//           14                    9                    9
//           15                   15                   15
//           16                    2                    2
//           17                    6                    6
//           18                   12                   12


Questo esempio funziona con gli elementi di testo tramite il metodo StringInfo.GetTextElementEnumerator e la classe TextElementEnumerator per enumerare tutti gli elementi di testo in una stringa. È inoltre possibile recuperare un array contenente l'indice iniziale di ogni elemento di testo chiamando il metodo StringInfo.ParseCombiningCharacters.

Per ulteriori informazioni sull'utilizzo delle unità di testo anziché i valori Char, consultare la classe StringInfo.

Stringhe null e stringhe vuote

Una stringa dichiarata ma a cui non è assegnato un valore è null. Il tentativo di chiamare metodi su quella stringa genera un'eccezione NullReferenceException. Una stringa Null è diversa da una stringa vuota il cui valore è "" o String.Empty. In alcuni casi, se si passa una stringa Null o una stringa vuota come argomento a una chiamata al metodo, viene generata un'eccezione. Ad esempio, se si passa una stringa Null al metodo Int32.Parse viene generata un'eccezione ArgumentNullException, mentre se si passa una stringa vuota viene generata un'eccezione FormatException. In altri casi un argomento del metodo può essere una stringa Null o una stringa vuota. Ad esempio, se si fornisce un'implementazione di IFormattable per una classe, può essere opportuno paragonare sia una stringa Null che una stringa vuota con l'identificatore di formato generale ("G").

La classe String include i seguenti due metodi pratici che consentono di testare se una stringa è null o vuota:

  • IsNullOrEmpty , che indica se una stringa è null o se è uguale a String.Empty. Questo metodo elimina la necessità di utilizzare codice come indicato di seguito:

    
    if (str == null || str.Equals(String.Empty))
    
    
    
  • IsNullOrWhiteSpace , che indica se una stringa è null, uguale a String.Empty o se è costituita esclusivamente da spazi vuoti. Questo metodo elimina la necessità di utilizzare codice come indicato di seguito:

    
    if (str == null || str.Equals(String.Empty) || str.Trim().Equals(String.Empty))
    
    
    

Nell'esempio seguente viene utilizzato il metodo IsNullOrEmpty nell'implementazione IFormattable.ToString di una classe Temperature personalizzata. Il metodo supporta le stringhe del formato "G", "C", "F" e "K". Se una stringa di formato vuoto o una stringa di formato il cui valore è null viene passata al metodo, il relativo valore viene modificato nella stringa di formato "G".


public string ToString(string format, IFormatProvider provider) 
{
   if (String.IsNullOrEmpty(format)) format = "G";  
   if (provider == null) provider = CultureInfo.CurrentCulture;

   switch (format.ToUpperInvariant())
   {
      // Return degrees in Celsius.    
      case "G":
      case "C":
         return temp.ToString("F2", provider) + "°C";
      // Return degrees in Fahrenheit.
      case "F": 
         return (temp * 9 / 5 + 32).ToString("F2", provider) + "°F";
      // Return degrees in Kelvin.
      case "K":   
         return (temp + 273.15).ToString();
      default:
         throw new FormatException(
               String.Format("The {0} format string is not supported.", 
                             format));
   }                                   
}


Immutabilità e la classe StringBuilder

L'oggetto String si definisce non modificabile, ovvero in sola lettura, perché una volta che è stato creato non è possibile cambiarne il valore. I metodi che sembrano modificare un oggetto String in realtà restituiscono un nuovo oggetto String contenente la modifica.

Poiché le stringhe non sono modificabili, le routine per la modifica di stringhe che eseguono aggiunte o eliminazioni ripetute rispetto a un elemento che sembra essere una singola stringa possono provocare una riduzione delle prestazioni significativa. Ad esempio, nel codice seguente viene utilizzato un generatore di numeri casuali per creare una stringa con 1000 caratteri nell'intervallo compreso tra 0x0001 e 0x052F. Sebbene sembri che il codice utilizzi una concatenazione di stringhe per accodare un nuovo carattere alla stringa esistente denominata str, in realtà crea un nuovo oggetto String per ogni operazione di concatenazione.


using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();

      string str = String.Empty;
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                           false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         str += Convert.ToChar(rnd.Next(1, 0x0530)); 
         if (str.Length % 60 == 0)
            str += Environment.NewLine;          
      }                    
      sw.Write(str);
      sw.Close();
   }
}


È possibile utilizzare la classe StringBuilder anziché la classe String per le operazioni che apportano più modifiche al valore di una stringa. Diversamente dalle stanze della classe String, gli oggetti StringBuilder sono modificabili; quando si concatenano, accodano o eliminano le sottostringhe da una stringa, le operazioni vengono eseguite su una singola stringa. Una volta terminata la modifica del valore di un oggetto StringBuilder, è possibile chiamare il metodo StringBuilder.ToString per convertirlo in una stringa. Nell'esempio seguente viene sostituito String utilizzato nell'esempio precedente per concatenare 1000 caratteri casuali nell'intervallo da 0x0001 a 0x052F con un oggetto StringBuilder.


using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      StringBuilder sb = new StringBuilder();
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                                         false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         sb.Append(Convert.ToChar(rnd.Next(1, 0x0530))); 
         if (sb.Length % 60 == 0)
            sb.AppendLine();          
      }                    
      sw.Write(sb.ToString());
      sw.Close();
   }
}


Ordinale per le operazioni dipendenti dalle impostazioni cultura

I membri della classe String eseguono operazioni ordinali o dipendenti dalle impostazioni cultura (linguistiche) su un oggetto String. Un'operazione ordinale agisce sul valore numerico di un oggetto Char. Un'operazione collegata alle impostazioni cultura, invece, agisce sul valore dell'oggetto String e tiene conto delle regole specifiche delle impostazioni cultura relative all'utilizzo di maiuscole e minuscole, alla formattazione, all'ordinamento e all'analisi. Le operazioni linguistiche vengono eseguite nel contesto di impostazioni cultura dichiarate in modo esplicito o delle impostazioni cultura correnti implicite. I due tipi di operazioni possono produrre risultati molto diversi quando vengono eseguiti sulla stessa stringa.

Nota sulla sicurezzaNota sulla sicurezza

Se in un'applicazione viene presa una decisione relativa alla sicurezza riguardo a un identificatore simbolico, quale un nome di file o una named pipe, o riguardo a dati mantenuti, quali i dati basati su testo in un file XML, l'operazione deve utilizzare un confronto ordinale anziché un confronto sensibile alle impostazioni cultura. Il motivo risiede nel fatto che un confronto sensibile alle impostazioni cultura può restituire risultati diversi in base alle impostazioni cultura attive, mentre un confronto ordinale dipende esclusivamente dal valore binario dei caratteri confrontati.

Nota importanteImportante

La maggior parte dei metodi che esegue operazioni di stringa includono un overload con un parametro di tipo StringComparison che consente di specificare se il metodo esegue un'operazione ordinale o dipendente dalle impostazioni cultura. In generale, è necessario chiamare questo overload per rendere chiaro lo scopo della chiamata al metodo. Per procedure consigliate e istruzione per l'utilizzo di operazioni ordinali e dipendenti dalle impostazioni cultura sulle stringhe, vedere Procedure consigliate per l'utilizzo di stringhe in .NET Framework.

Le operazioni per il casing, parsing e formattazione, confronto e ordinamento e test di uguaglianza possono essere numeri ordinali o dipendenti dalle impostazioni cultura. Nelle sezioni seguenti viene discussa ogni categoria di operazione.

s1wwdcbf.collapse_all(it-it,VS.110).gifUtilizzo di maiuscole e minuscole

Le regole relative all'utilizzo di maiuscole e minuscole determinano le modalità di modifica di un carattere Unicode, ad esempio da minuscolo a maiuscolo. Spesso un'operazione di distinzione tra maiuscole e minuscole viene eseguita prima di un confronto di stringhe. Ad esempio, una stringa potrebbe essere convertita in lettere maiuscole in modo che sia possibile confrontarla con un'altra stringa in maiuscolo. È possibile convertire i caratteri di una stringa in minuscolo chiamando il metodo ToLower o ToLowerInvariant ed è possibile convertirli in maiuscolo chiamando il metodo ToUpper o ToUpperInvariant. È possibile inoltre utilizzare il metodo TextInfo.ToTitleCase per convertire una stringa in Tutte Iniziali Maiuscole.

Le operazioni relative all'utilizzo di maiuscole e minuscole possono essere basate sulle regole delle impostazioni cultura correnti, di impostazioni cultura specificate o della lingua inglese. Poiché i mapping di maiuscole e minuscole possono variare in base alle impostazioni cultura utilizzate, il risultato delle operazioni di maiuscole e minuscole può variare in base alle impostazioni cultura. Le effettive differenze tra maiuscole e minuscole sono di tre tipi:

  • Differenze nel mapping di maiuscole e minuscole di LATIN CAPITAL LETTER I (U+0049), LATIN SMALL LETTER I (U+0069), LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130), e LATIN SMALL LETTER DOTLESS I (U+0131). In tr-TR (la lingua turca parlata in Turchia)) e le impostazioni cultura latina dell'Azerbaijan az-Latn-AZ, e nelle culture neutrali tr, az e az-Latn, l'equivalente minuscolo di LETTERA CAPITAL LETTER I è LATIN SMALL LETTER DOTLESS I e l'equivalente maiuscolo la LATIN SMALL LETTER I è LATIN CAPITAL LETTER I WITH DOT ABOVE. In tutte le altre impostazioni cultura, tra cui la lingua inglese, LATIN SMALL LETTER I e LATIN CAPITAL LETTER I sono equivalenti sia in maiuscolo che in minuscolo.

    Nell'esempio seguente viene mostrato un confronto di stringhe progettato per impedire che l'accesso di file system possa non riuscire se si basa su un confronto dipendente dalle impostazioni cultura tra maiuscole e minuscole. (Devono essere utilizzate le convenzioni sulla combinazione di maiuscole e minuscole delle impostazioni cultura invarianti.)

    
    using System;
    using System.Globalization;
    using System.Threading;
    
    public class Example
    {
       const string disallowed = "file";
    
       public static void Main()
       {
          IsAccessAllowed(@"FILE:\\\c:\users\user001\documents\FinancialInfo.txt");
       }
    
       private static void IsAccessAllowed(String resource)
       {
          CultureInfo[] cultures = { CultureInfo.CreateSpecificCulture("en-US"),
                                     CultureInfo.CreateSpecificCulture("tr-TR") };
          String scheme = null;
          int index = resource.IndexOfAny( new Char[] { '\\', '/' } );
          if (index > 0) 
             scheme = resource.Substring(0, index - 1);
    
          // Change the current culture and perform the comparison.
          foreach (var culture in cultures) {
             Thread.CurrentThread.CurrentCulture = culture;
             Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName);
             Console.WriteLine(resource);
             Console.WriteLine("Access allowed: {0}", 
                               ! String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase));      
             Console.WriteLine();
          }   
       }
    }
    // The example displays the following output:
    //       Culture: English (United States)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: False
    //       
    //       Culture: Turkish (Turkey)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: True
    
    
    
  • Differenze nei mapping tra la lingua inglese e tutte le altre impostazioni cultura. In questi casi, l'utilizzo delle regole di utilizzo di maiuscole e minuscole delle impostazioni cultura invarianti per modificare un carattere in maiuscolo o minuscolo restituisce lo stesso carattere. Per tutte le altre impostazioni cultura, restituisce un carattere diverso. Alcuni dei caratteri interessati sono elencati nella seguente tabella.

    Carattere

    Se modificate in

    Valore restituito

    MICRON SIGN (U+00B5)

    Maiuscole

    GREEK CAPITAL LETTER MU (U+-39C)

    LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130)

    Minuscole

    LATIN SMALL LETTER I (U+0069)

    LETTERA MINUSCOLA LETTER I DOTLESS (U+0131)

    Maiuscole

    LATIN CAPITAL LETTER I (U+0049)

    LATIN SMALL LETTER LONG S (U+017F)

    Maiuscole

    LATIN CAPITAL LETTER S (U+0053)

    LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON (U+01C5)

    Minuscole

    LATIN SMALL LETTER DZ WITH CARON (U+01C6)

    COMBINING GREEK YPOGEGRAMMENI (U+0345)

    Maiuscole

    GREEK CAPITAL LETTER IOTA (U+0399)

  • Differenze nei mapping delle coppie di due lettere di lettere maiuscole e minuscole nell'intervallo dei caratteri ASCII. Nella maggior parte delle impostazioni cultura, una coppia di due lettere maiuscole e minuscole è uguale alle equivalenti due lettere maiuscole o alla coppia di minuscole. Ciò non accade per le coppie di due lettere nelle seguenti impostazioni cultura, perché in ogni caso vengono confrontate a un digramma:

    • "lJ" e "nJ" nella lingua hr-HR (croato (Croazia).

    • "cH" nelle lingue cs-CZ (ceco (Repubblica Ceca) e sk-sk (slovacco (Repubblica Slovacca)).

    • "aA" nella lingua da-dk (danese (Danimarca)).

    • "cS", "dZ", "dZS", "nY", "sZ", "tY" e "zS" nella lingua hu-hu (ungherese (Ungheria)).

    • "cH" e "lL" nella lingua es-ES_tradnl (spagnolo (Spagna, tradizionale)).

    • "cH", "gi", "kH", "nG" "nH", "pH", "qU, "tH" e "tR" nella lingua vi-vn (vietnamita (Vietnam)).

    Tuttavia, è difficile da rilevare una situazione in cui un confronto dipendente dalle impostazioni cultura di queste coppie possa causare dei problemi, poiché queste coppie sono rare nelle stringhe fisse o negli identificatori.

Nell'esempio seguente sono illustrate alcune differenze delle regole di combinazione di maiuscole e minuscole tra le impostazioni cultura quando si convertono le stringhe in maiuscolo.


using System;
using System.Globalization;
using System.IO;

public class Example
{
   public static void Main()
   {
      StreamWriter sw = new StreamWriter(@".\case.txt");   
      string[] words = { "file", "sıfır", "Dženana" };
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"),  
                                 new CultureInfo("tr-TR") };

      foreach (var word in words) {
         sw.WriteLine("{0}:", word);
         foreach (var culture in cultures) {
            string name = String.IsNullOrEmpty(culture.Name) ? 
                                 "Invariant" : culture.Name;
            string upperWord = word.ToUpper(culture);
            sw.WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                         upperWord, ShowHexValue(upperWord));

         }
         sw.WriteLine();  
      }
      sw.Close();
   }

   private static string ShowHexValue(string s)
   {
      string retval = null;
      foreach (var ch in s) {
         byte[] bytes = BitConverter.GetBytes(ch);
         retval += String.Format("{0:X2} {1:X2} ", bytes[1], bytes[0]);     
      }
      return retval;
   } 
}
// The example displays the following output:
//    file:
//        Invariant:    FILE               00 46 00 49 00 4C 00 45 
//            en-US:    FILE               00 46 00 49 00 4C 00 45 
//            tr-TR:    FİLE               00 46 01 30 00 4C 00 45 
//    
//    sıfır:
//        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52 
//            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//    
//    Dženana:
//        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41 
//            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
//            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 


s1wwdcbf.collapse_all(it-it,VS.110).gifAnalisi e formattazione

La formattazione e l'analisi sono due operazioni inverse. Le regole di formattazione stabiliscono le modalità di conversione di un valore, ad esempio una data e ora o un numero, nella relativa rappresentazione di stringa, mentre le regole di analisi determinano le modalità di conversione di una rappresentazione di stringa in un valore, ad esempio una data e ora. Sia le regole di analisi che quelle di formattazione dipendono dalle convenzioni relative alla lingua. Nell'esempio seguente viene illustrata l'ambiguità che può sorgere quando si interpreta una stringa di data specifica delle impostazioni cultura. Se non si conoscono le convenzioni delle impostazioni cultura utilizzate per produrre una stringa relativa alla data, non è possibile sapere se 03/01/2011, 3/1/2011 e 01/03/2011 rappresentano il 3 gennaio 2011 o il 1 marzo 2011.


using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime date = new DateTime(2011, 3, 1);
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"), 
                                 new CultureInfo("fr-FR") };

      foreach (var culture in cultures)
         Console.WriteLine("{0,-12} {1}", String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.ToString("d", culture));                                    
   }
}
// The example displays the following output:
//       Invariant    03/01/2011
//       en-US        3/1/2011
//       fr-FR        01/03/2011


In modo analogo, come mostra l'esempio seguente, una singola stringa può produrre date diverse a seconda delle impostazioni cultura le cui convenzioni vengono utilizzate nell'operazione di analisi.


using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string dateString = "07/10/2011";
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 CultureInfo.CreateSpecificCulture("en-GB"), 
                                 CultureInfo.CreateSpecificCulture("en-US") };
      Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}\n", "Date String", "Culture", 
                                                 "Month", "Day");
      foreach (var culture in cultures) {
         DateTime date = DateTime.Parse(dateString, culture);
         Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                           String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.Month, date.Day);
      }                      
   }
}
// The example displays the following output:
//       Date String     Culture    Month      Day
//       
//       07/10/2011    Invariant        7       10
//       07/10/2011        en-GB       10        7
//       07/10/2011        en-US        7       10


s1wwdcbf.collapse_all(it-it,VS.110).gifConfronto e ordinamento di stringhe

Convenzioni per il confronto e l'ordinamento delle stringhe variano in base alle impostazioni cultura. Ad esempio, l'ordinamento può essere basato su fonetica o sulla rappresentazione visiva dei caratteri. Nelle lingue dell'Estremo Oriente i caratteri vengono disposti in base al tratto e al radicale degli ideogrammi. L'ordinamento dipende anche dai linguaggi di ordinamento e dall'utilizzo delle impostazioni cultura per l'alfabeto. La lingua svedese, ad esempio, dispone di un carattere "Æ" che viene ordinato alfabeticamente dopo la lettera "Z". Inoltre, i confronti possono distinzione tra maiuscole e minuscole o senza distinzione tra maiuscole e minuscole e le regole di utilizzo di maiuscole e minuscole differiscono in alcuni casi dalle impostazioni cultura. Il confronto ordinale, invece, vengono utilizzati i punti di codice Unicode i singoli caratteri in una stringa nel confronto e l'ordinamento delle stringhe.

Le regole di ordinamento determinano l'ordine alfabetico dei caratteri Unicode e le modalità di confronto fra due stringhe. Ad esempio, il metodo String.Compare(String, String, StringComparison) confronta due stringhe basate sul parametro StringComparison. Se il valore del parametro è StringComparison.CurrentCulture, il metodo esegue un confronto linguistico che utilizza le convenzioni delle impostazioni cultura correnti. Se invece il valore del parametro è StringComparison.Ordinal, il metodo esegue un confronto ordinale. Di conseguenza, come illustrato nell'esempio, se le impostazioni cultura correnti sono Inglese statunitense, la prima chiamata al metodo String.Compare(String, String, StringComparison) (utilizzando un confronto dipendente dalle impostazioni cultura) considera "a" minore di "A", mentre la seconda chiamata allo stesso metodo (utilizzando un confronto ordinale) considera "a" maggiore di "A".


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

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
      Console.WriteLine(String.Compare("A", "a", StringComparison.CurrentCulture));
      Console.WriteLine(String.Compare("A", "a", StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       1
//       -32


In .NET Framework sono supportate le regole di ordinamento basate su parola, stringa e ordinale:

  • Un ordinamento per parola consente di eseguire un confronto basato sulle impostazioni cultura tra stringhe in cui a determinati caratteri Unicode non alfanumerici potrebbero essere assegnati determinati pesi. Il trattino (-), ad esempio, potrebbe avere un peso minimo in modo che "coop" e "co-op" risultino vicini in un elenco ordinato. Per un elenco dei metodi String che confrontano due stringhe in base a regole di ordinamento per parola, consultare la sezione .

  • L'ordinamento per stringa effettua un confronto con distinzione tra maiuscole e minuscole. È simile ad un ordinamento basato su parola, tranne per il fatto che non sono previsti casi speciali e tutti i simboli non alfanumerici sono riportati prima di tutti i caratteri Unicode alfanumerici. È possibile confrontare due stringhe utilizzando regole di ordinamento delle stringhe chiamando gli overload del metodo CompareInfo.Compare che hanno un parametro options che fornisce il valore CompareOptions.StringSort. Si noti che questo è il solo metodo che .NET Framework fornisce per confrontare due stringhe utilizzando regole dell'ordinamento delle stringhe.

  • Infine, nell'ordinamento basato su ordinale, le stringhe vengono confrontate in base al valore numerico di ogni oggetto Char nella stringa. Un confronto ordinale esegue automaticamente la distinzione tra maiuscole e minuscole poiché la versione maiuscola e quella minuscola di un carattere hanno punti di codice diversi. Tuttavia, se la distinzione tra maiuscole e minuscole non è importante, è possibile specificare un confronto ordinale che ignori tale distinzione. Questa operazione equivale alla conversione della stringa in lettere maiuscole tramite le impostazioni cultura invarianti e alla successiva esecuzione di un confronto ordinale sul risultato. Per un elenco dei metodi String che confrontano due stringhe in base a regole di ordinamento ordinale, consultare la sezione .

Un confronto sensibile alle impostazioni cultura è un qualsiasi confronto che utilizza in modo esplicito o implicito un oggetto CultureInfo, comprese le impostazioni cultura invarianti specificate dalla proprietà CultureInfo.InvariantCulture. Le impostazioni cultura implicite sono quelle correnti, ossia quelle specificate dalle proprietà Thread.CurrentCulture e CultureInfo.CurrentCulture. C'è una variazione notevole nell'ordinamento di caratteri alfabetici (cioè caratteri per i quali la proprietà Char.IsLetter restituisce true) tramite le impostazioni cultura. È possibile specificare un confronto dipendente dalle impostazioni cultura che utilizza le convenzioni delle impostazioni cultura specifiche fornendo un oggetto CultureInfo a un metodo di confronto di stringhe come Compare(String, String, CultureInfo, CompareOptions). È possibile specificare un confronto dipendente dalle impostazioni cultura che utilizza le convenzioni delle impostazioni cultura correnti fornendo StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCase, o qualsiasi membro di enumerazione CompareOptions diverso da CompareOptions.Ordinal o CompareOptions.OrdinalIgnoreCase a un overload appropriato del metodo Compare. Un confronto sensibile alle impostazioni cultura è in genere appropriato per l'ordinamento a differenza di un confronto ordinale. Un confronto ordinale è in genere appropriato per determinare se due stringhe sono uguali (ovvero per determinare l'identità) a differenza di un confronto sensibile alle impostazioni cultura.

Nell'esempio seguente viene illustrata la differenza tra le impostazioni cultura e il confronto ordinale. L'esempio valuta tre stringhe, "e", "Æble" e "AEble", utilizzando convenzioni di da-dk e le impostazioni cultura en-US (ognuno dei quali rappresenta le impostazioni cultura predefinite al momento del metodo di Compare viene chiamato) nonché il confronto ordinale. Poiché la lingua danese considera il carattere "Æ" come una lettera e ordinati dopo "Z" nell'alfabeto, la stringa "Æble" è maggiore di "e". Tuttavia, "Æble" non è considerato equivalente a "AEble", pertanto "Æble" è maggiore di "AEble". Le impostazioni cultura en-US non hanno lettera Æ ma considera come "crittografia asimmetrica" equivalente, che viene spiegato perché "Æble" è minore di "Apple" ma non uguale a "AEble". Il confronto ordinale, invece, sono considerati "e" minore di "Æble" e il ttto "di Æble" sia maggiore di "AEble".


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

public class CompareStringSample
{
   public static void Main()
   {
      string str1 = "Apple";
      string str2 = "Æble"; 
      string str3 = "AEble";

      // Set the current culture to Danish in Denmark.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));

      // Set the current culture to English in the U.S.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));

      // Perform an ordinal comparison.
      Console.WriteLine("Ordinal comparison");
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, 
                        String.Compare(str1, str2, StringComparison.Ordinal));
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, 
                        String.Compare(str2, str3, StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       Current culture: da-DK
//       Comparison of Apple with Æble: -1
//       Comparison of Æble with AEble: 1
//       
//       Current culture: en-US
//       Comparison of Apple with Æble: 1
//       Comparison of Æble with AEble: 0
//       
//       Ordinal comparison
//       Comparison of Apple with Æble: -133
//       Comparison of Æble with AEble: 133


Utilizzare le seguente regole generali per scegliere un metodo di confronto di stringhe o di ordinamento:

  • Se si desidera che le stringhe siano ordinate in base alle impostazioni cultura dell'utente, è necessario ordinarle in base alle convenzioni delle impostazioni cultura correnti. Se le impostazioni cultura dell'utente vengono cambiate, anche l'ordine delle stringhe ordinate cambieranno di conseguenza. Ad esempio, un'applicazione di thesaurus deve ordinare sempre le parole basate sulle impostazioni cultura dell'utente.

  • Se si desidera che le stringhe siano ordinate in base alle convenzioni delle impostazioni cultura specifiche, è necessario ordinarle fornendo un oggetto CultureInfo che rappresenta le impostazioni cultura a un metodo di confronto. Ad esempio, in un'applicazione progettata per insegnare a studenti a un particolare linguaggio, si desidererà che le stringhe siano ordinate in base alle convenzioni delle impostazioni cultura di quel linguaggio.

  • Se si desidera che l'ordinamento delle stringhe rimanga invariato nelle impostazioni cultura, è necessario ordinarli in base alle convenzioni per la lingua inglese o utilizzare un confronto ordinale. Ad esempio, si desidera utilizzare un ordinamento ordinale per organizzare i nomi dei file, processi, mutex, o pipe.

  • Per un confronto che include una decisione relativa alla sicurezza (ad esempio se un nome utente è valido), è necessario eseguire sempre un test ordinale per l'uguaglianza chiamando un overload del metodo Equals.

NotaNota

L'ordinamento dipendente dalle impostazioni cultura e le regole di utilizzo di maiuscole e minuscole usati nel confronto di stringhe dipendono dalla versione di .NET Framework. In .NET Framework 4.5 in esecuzione nel sistema operativo Windows 8, l'ordinamento, le maiuscole e minuscole, la normalizzazione e le informazioni di caratteri unicode sono conformi allo standard Unicode 6.0. In altri sistemi operativi, è conforme allo standard Unicode 5.0.

Per ulteriori informazioni sulle regole di ordinamento per parola, per stringa e ordinale, vedere l'argomento System.Globalization.CompareOptions. Per ulteriori consigli su quando utilizzare ogni regola, consultare Procedure consigliate per l'utilizzo di stringhe in .NET Framework.

In genere, non si chiamano direttamente metodi per il confronto di stringhe, ad esempio Compare, per determinare l'ordinamento di stringhe. Al contrario, i metodi di confronto vengono chiamati da un metodo di ordinamento, ad esempio Array.Sort o List<T>.Sort. Nell'esempio seguente viene eseguito quattro operazioni di ordinamento diverse (ordinamento di parole utilizzando le impostazioni cultura correnti, ordinamento di parole utilizzando la lingua inglese, ordinamento basato su ordinale e l'ordinamento delle stringhe utilizzando la lingua inglese) senza una chiamata esplicita a un metodo di confronto di stringhe, anche se per specificare il tipo di confronto che l'ordinamento è utilizzare. Si noti che ogni tipo di ordinamento produce un ordine univoco di stringhe nella matrice.


using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string[] strings = { "coop", "co-op", "cooperative", 
                           "co\u00ADoperative", "cœur", "coeur" };

      // Perform a word sort using the current (en-US) culture.
      string[] current = new string[strings.Length]; 
      strings.CopyTo(current, 0); 
      Array.Sort(current, StringComparer.CurrentCulture);

      // Perform a word sort using the invariant culture.
      string[] invariant = new string[strings.Length];
      strings.CopyTo(invariant, 0); 
      Array.Sort(invariant, StringComparer.InvariantCulture);

      // Perform an ordinal sort.
      string[] ordinal = new string[strings.Length];
      strings.CopyTo(ordinal, 0); 
      Array.Sort(ordinal, StringComparer.Ordinal);

      // Perform a string sort using the current culture.
      string[] stringSort = new string[strings.Length];
      strings.CopyTo(stringSort, 0); 
      Array.Sort(stringSort, new SCompare());

      // Display array values
      Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}\n", 
                        "Original", "Word Sort", "Invariant Word", 
                        "Ordinal Sort", "String Sort");
      for (int ctr = 0; ctr < strings.Length; ctr++)
         Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                           strings[ctr], current[ctr], invariant[ctr], 
                           ordinal[ctr], stringSort[ctr] );          
   }
}

// IComparer<String> implementation to perform string sort.
internal class SCompare : IComparer<String>
{
   public int Compare(string x, string y)
   {
      return CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort);
   }
}
// The example displays the following output:
//         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort
//    
//             coop          cœur            cœur         co-op         co-op
//            co-op         coeur           coeur         coeur          cœur
//      cooperative          coop            coop          coop         coeur
//     co­operative         co-op           co-op   cooperative          coop
//             cœur   cooperative     cooperative  co­operative   cooperative
//            coeur  co­operative    co­operative          cœur  co­operative


SuggerimentoSuggerimento

Internamente, .NET Framework utilizza le chiavi di ordinamento per supportare il confronto di stringhe culturale- riservato. Ciascun carattere di una stringa è assegnato a diverse categorie di fattori di ordinamento, inclusi i caratteri alfabetici, le combinazioni di maiuscole e minuscole e i caratteri diacritici. Una chiave di ordinamento, rappresentata dalla classe di SortKey, fornisce un repository di questi fattori per una determinata stringa. Se l'applicazione esegue tantissima ricerca o operazioni di ordinamento nello stesso insieme di stringhe, è possibile migliorare le prestazioni generando e memorizzando le chiavi di ordinamento per tutte le stringhe utilizzati. Quando un ordinamento o un'operazione di confronto è necessario, vengono utilizzate chiavi di ordinamento anziché le stringhe. Per ulteriori informazioni, vedere la classe SortKey.

Se non si specifica una convenzione di confronto di stringhe, i metodi di cernita come Array.Sort(Array) esegue un ordinamento dipendente dalle impostazioni cultura e con distinzione tra maiuscole e minuscole nelle stringhe. Nell'esempio seguente viene illustrato come modificare le impostazioni cultura correnti riguarda l'ordine delle stringhe ordinate in una matrice. Crea una matrice di tre stringhe. Innanzitutto, imposta la proprietà System.Threading.Thread.CurrentThread.CurrentCulture su en-US e viene chiamato il metodo Array.Sort(Array). Il criterio di ordinamento risultante è basato sulle convenzioni di ordinamento delle impostazioni cultura Inglese (Stati Uniti). Successivamente, l'esempio imposta la proprietà System.Threading.Thread.CurrentThread.CurrentCulture su da-DK e viene chiamato nuovamente il metodo Array.Sort. Si noti che il criterio di ordinamento risultante differisce da en-US in quanto vengono utilizzate le convenzioni di ordinamento per le impostazioni di lingua da-DK .


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

public class ArraySort 
{
   public static void Main(String[] args) 
   {
      // Create and initialize a new array to store the strings.
      string[] stringArray = { "Apple", "Æble", "Zebra"};

      // Display the values of the array.
      Console.WriteLine( "The original string array:");
      PrintIndexAndValues(stringArray);

      // Set the CurrentCulture to "en-US".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      // Sort the values of the array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"en-US\":");
      PrintIndexAndValues(stringArray); 

      // Set the CurrentCulture to "da-DK".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      // Sort the values of the Array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"da-DK\":");
      PrintIndexAndValues(stringArray); 
   }
   public static void PrintIndexAndValues(string[] myArray)  
   {
      for (int i = myArray.GetLowerBound(0); i <= 
            myArray.GetUpperBound(0); i++ )
         Console.WriteLine("[{0}]: {1}", i, myArray[i]);
      Console.WriteLine();      
   }
}
// The example displays the following output:
//       The original string array:
//       [0]: Apple
//       [1]: Æble
//       [2]: Zebra
//       
//       After sorting for the "en-US" culture:
//       [0]: Æble
//       [1]: Apple
//       [2]: Zebra
//       
//       After sorting for the culture "da-DK":
//       [0]: Apple
//       [1]: Zebra
//       [2]: Æble


Nota di avvisoAttenzione

Se lo scopo primario nel confronto di stringhe è quello di determinare se sono uguali, è necessario chiamare il metodo String.Equals. In genere, è necessario utilizzare Equals per eseguire un confronto ordinale. Il metodo String.Compare è fondamentalmente destinato ad ordinare stringhe.

I metodi di ricerca stringa, ad esempio String.StartsWith e String.IndexOf possono eseguire anche confronti di stringhe dipendenti dalle impostazioni cultura o ordinali. Nell'esempio seguente sono illustrate le differenze fra confronti dipendenti dalle impostazioni cultura e ordinali utilizzando il metodo IndexOf. Una ricerca dipendente dalle impostazioni cultura nella quale le impostazioni cultura correnti sono inglese (Stati Uniti) considera che la sottostringa "oe" corrisponda alla legatura "œ". Poiché un segno meno facoltativo (U+00AD) è un carattere di larghezza zero, la ricerca lo tratta come equivalente a Empty e trova una corrispondenza all'inizio della stringa. Una ricerca ordinale, tuttavia, non sarà in grado di trovare una corrispondenza in alcuno dei casi.


using System;

public class Example
{
   public static void Main()
   {
      // Search for "oe" and "œu" in "œufs" and "oeufs".
      string s1 = "œufs";
      string s2 = "oeufs";
      FindInString(s1, "oe", StringComparison.CurrentCulture);
      FindInString(s1, "oe", StringComparison.Ordinal);
      FindInString(s2, "œu", StringComparison.CurrentCulture);
      FindInString(s2, "œu", StringComparison.Ordinal);
      Console.WriteLine();

      string s3 = "co\u00ADoperative";
      FindInString(s3, "\u00AD", StringComparison.CurrentCulture);
      FindInString(s3, "\u00AD", StringComparison.Ordinal);
   }

   private static void FindInString(string s, string substring, StringComparison options)
   {
      int result = s.IndexOf(substring, options);
      if (result != -1)
         Console.WriteLine("'{0}' found in {1} at position {2}", 
                           substring, s, result);
      else
         Console.WriteLine("'{0}' not found in {1}", 
                           substring, s);                                                  
   }
}
// The example displays the following output:
//       'oe' found in œufs at position 0
//       'oe' not found in œufs
//       'œu' found in oeufs at position 0
//       'œu' not found in oeufs
//       
//       '­' found in co­operative at position 0
//       '­' found in co­operative at position 2


s1wwdcbf.collapse_all(it-it,VS.110).gifRicerca di stringhe

Stringa contenente metodi di ricerca, come String.StartsWith e String.IndexOf, può inoltre eseguire confronti di stringhe dipendenti dalle impostazioni cultura o ordinali per determinare se un carattere o una sottostringa viene trovato in una stringa specificata.

I metodi di ricerca consentono di trovare un carattere o quello di un set di caratteri in una stringa, o trovare una sottostringa in una stringa. I metodi di ricerca in String classe che la ricerca di un singolo carattere, come metodo di IndexOf, o una di un set di caratteri, ad esempio il metodo di IndexOfAny, l'unica operazione viene eseguita una ricerca di ordinale. Per eseguire una ricerca dipendente dalle impostazioni cultura di un carattere, è necessario chiamare un metodo di CompareInfo come CompareInfo.IndexOf(String, Char) o CompareInfo.LastIndexOf(String, Char). Si noti che i risultati di ricerca un carattere tramite ordinale e confronto dipendente dalle impostazioni cultura possono essere molto diversi. Ad esempio, una ricerca di un carattere unicode precomposed come la legatura "Æ" (U+00C6) può corrispondere a qualsiasi occorrenza dei componenti nella sequenza corretta, ad esempio "crittografia asimmetrica" (U+041U+0045), a seconda delle impostazioni cultura. Nell'esempio seguente viene illustrata la differenza tra String.IndexOf(Char) e i metodi di CompareInfo.IndexOf(String, Char) quando trova un solo carattere. La legatura "æ" (U+00E6) viene trovata la stringa "antenna" quando si utilizzano le convenzioni delle impostazioni cultura en-US, ma non quando utilizzando le convenzioni delle impostazioni cultura da-dk o durante l'esecuzione di un confronto ordinale.


using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      String[] cultureNames = { "da-DK", "en-US" };
      CompareInfo ci;
      String str = "aerial";
      Char ch = 'æ';  // U+00E6

      Console.Write("Ordinal comparison -- ");
      Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                        str.IndexOf(ch));

      foreach (var cultureName in cultureNames) {
         ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo;
         Console.Write("{0} cultural comparison -- ", cultureName);
         Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                           ci.IndexOf(str, ch));
      }
   }
}
// The example displays the following output:
//       Ordinal comparison -- Position of 'æ' in aerial: -1
//       da-DK cultural comparison -- Position of 'æ' in aerial: -1
//       en-US cultural comparison -- Position of 'æ' in aerial: 0


Di altra parte, i metodi della classe di String a cercare una stringa anziché un carattere eseguono una ricerca dipendente dalle impostazioni cultura se le opzioni di ricerca non sono specificati in modo esplicito da un parametro di tipo StringComparison. L'eccezione è solo Contains, che esegue una ricerca ordinale.

s1wwdcbf.collapse_all(it-it,VS.110).gifVerifica dell'uguaglianza

Utilizzare il metodo String.Compare per determinare la relazione di due stringhe nell'ordinamento. In genere, si tratta di un'operazione dipendente dalle impostazioni cultura. Al contrario, chiamare il metodo String.Equals per verificare l'uguaglianza. Poiché di solito confronta input dell'utente con alcune stringhe note, quali un nome utente valido, una password o un percorso di file system, il test per l'uguaglianza è in genere un'operazione ordinale.

Nota di avvisoAttenzione

È possibile verificare l'uguaglianza chiamando il metodo String.Compare e determinando se il valore restituito è zero. Tuttavia, questa operazione non è consigliata. Per determinare se due stringhe sono uguali, è necessario chiamare uno degli overload del metodo String.Equals. L'overload preferito da chiamare è il metodo Equals(String, StringComparison) dell'istanza o il metodo Equals(String, String, StringComparison) statico, perché entrambi i metodi includono un parametro System.StringComparison che specifica in modo esplicito il tipo di confronto.

Nell'esempio seguente viene illustrato il pericolo dell'esecuzione di un confronto di uguaglianza dipendente dalle impostazioni cultura quando deve essere utilizzato un ordinale. In questo caso lo scopo del codice è quello di proibire l'accesso al file system da URL che iniziano con "FILE://" o "file://" eseguendo un confronto senza distinzione tra maiuscole e minuscole della parte iniziale dell'URL con la stringa "FILE://". Tuttavia, se un confronto dipendente dalle impostazioni cultura viene eseguito utilizzando le impostazioni cultura turche (Turchia) in un URL che inizia con "file://", il confronto per l'uguaglianza non riesce perché l'equivalente maiuscolo turco della lettera minuscola "i" è "İ" e non "I". Di conseguenza, l'accesso al file system è consentito inavvertitamente. D'altra parte, se viene eseguito un confronto ordinale, il confronto per l'uguaglianza riesce e l'accesso al file system viene negato.


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

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR");      

      string filePath = "file://c:/notes.txt";

      Console.WriteLine("Culture-sensitive test for equality:");
      if (! TestForEquality(filePath, StringComparison.CurrentCultureIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);

      Console.WriteLine("\nOrdinal test for equality:");
      if (! TestForEquality(filePath, StringComparison.OrdinalIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);
   }

   private static bool TestForEquality(string str, StringComparison cmp)
   {
      int position = str.IndexOf("://");
      if (position < 0) return false;

      string substring = str.Substring(0, position);  
      return substring.Equals("FILE", cmp);
   }
}
// The example displays the following output:
//       Culture-sensitive test for equality:
//       Access to file://c:/notes.txt is allowed.
//       
//       Ordinal test for equality:
//       Access to file://c:/notes.txt is not allowed.


Normalizzazione

Alcuni caratteri Unicode dispongono di più rappresentazioni. Ad esempio, uno qualsiasi dei punti di codice seguenti può rappresentare la lettera "ắ":

  • U+1EAF

  • U+0103 U+0301

  • U+0061 U+0306 U+0301

La presenza di più rappresentazioni per un unico carattere rende più complesse la ricerca, l'ordinamento, l'associazione e altre operazioni relative alle stringhe.

Nello standard Unicode viene definito un processo denominato normalizzazione che restituisce una rappresentazione binaria di un carattere Unicode per qualsiasi rappresentazione binaria equivalente relativa. Per la normalizzazione è possibile utilizzare diversi algoritmi, denominati formati di normalizzazione, che seguono regole diverse. In .NET Framework sono supportati i formati di normalizzazione Unicode C, D, KC e KD. Quando le stringhe sono state normalizzate nello stesso formato di normalizzazione, possono essere confrontate mediante un confronto ordinale.

Un confronto ordinale rappresenta un confronto binario del valore scalare Unicode di oggetti corrispondenti Char in ogni stringa. La classe String include diversi metodi che consentono di eseguire un confronto ordinale, tra cui:

È possibile determinare se una stringa viene normalizzata nel formato di normalizzazione C chiamando il metodo String.IsNormalized() o è possibile chiamare il metodo String.IsNormalized(NormalizationForm) per determinare se una stringa viene normalizzata in un formato di normalizzazione specificato. È anche possibile chiamare il metodo String.Normalize() per convertire una stringa nel formato di normalizzazione C o è possibile chiamare il metodo String.Normalize(NormalizationForm) per convertire una stringa in un formato di normalizzazione specificato. Per informazioni dettagliate sulla normalizzazione e confrontare stringhe, consultare i metodi Normalize(NormalizationForm) e Normalize().

Nel semplice esempio seguente viene illustrata la normalizzazione delle stringhe. Definisce la lettera "ố" in tre modi diversi e in tre stringhe distinte e utilizza un confronto ordinale per stabilire l'uguaglianza e per determinare che ogni stringa differisce dalle altre due. Converte quindi ogni stringa nei formati di normalizzazione supportati forma ed esegue nuovamente un confronto ordinale di ogni stringa in un formato di normalizzazione specificato. In ogni caso, il secondo test per l'uguaglianza mostra che le stringhe sono uguali.


using System;
using System.Globalization;
using System.IO;
using System.Text;

public class Example
{
   private static StreamWriter sw;

   public static void Main()
   {
      sw = new StreamWriter(@".\TestNorm1.txt");

      // Define three versions of the same word. 
      string s1 = "sống";        // create word with U+1ED1
      string s2 = "s\u00F4\u0301ng";
      string s3 = "so\u0302\u0301ng";

      TestForEquality(s1, s2, s3);      
      sw.WriteLine();

      // Normalize and compare strings using each normalization form.
      foreach (string formName in Enum.GetNames(typeof(NormalizationForm)))
      {
         sw.WriteLine("Normalization {0}:\n", formName); 
         NormalizationForm nf = (NormalizationForm) Enum.Parse(typeof(NormalizationForm), formName);
         string[] sn = NormalizeStrings(nf, s1, s2, s3);
         TestForEquality(sn);           
         sw.WriteLine("\n");                                        
      }

      sw.Close();   
   }

   private static void TestForEquality(params string[] words)
   {
      for (int ctr = 0; ctr <= words.Length - 2; ctr++)
         for (int ctr2 = ctr + 1; ctr2 <= words.Length - 1; ctr2++) 
            sw.WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words[ctr], ShowBytes(words[ctr]),
                         words[ctr2], ShowBytes(words[ctr2]),
                         words[ctr].Equals(words[ctr2], StringComparison.Ordinal));
   }

   private static string ShowBytes(string str)
   {
      string result = null;
      foreach (var ch in str)
         result += String.Format("{0} ", Convert.ToUInt16(ch).ToString("X4")); 
      return result.Trim();            
   } 

   private static string[] NormalizeStrings(NormalizationForm nf, params string[] words)
   {
      for (int ctr = 0; ctr < words.Length; ctr++)
         if (! words[ctr].IsNormalized(nf))
            words[ctr] = words[ctr].Normalize(nf); 
      return words;   
   }
}
// The example displays the following output:
//       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False
//       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       
//       Normalization FormC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       
//       
//       Normalization FormKC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormKD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True


Per ulteriori informazioni sulla normalizzazione e sui formati di normalizzazione, consultare System.Text.NormalizationFormnonché Unicode Standard Annex #15: Forme sulla Normalizzazione di Unicode e Domande frequenti sulla normalizzazione sul sito Web unicode.org.

Operazioni su stringhe per categoria

La classe String fornisce membri per il confronto di stringhe, il test di uguaglianza delle stringhe, la ricerca di caratteri o sottostringhe in una stringa, la modifica una stringa, l'estrazione di sottostringhe da una stringa, la combinazione di stringhe, la formattazione di valori, la copia di una stringa e la normalizzazione di una stringa.

s1wwdcbf.collapse_all(it-it,VS.110).gifConfronto di stringhe

È possibile confrontare le stringhe per determinarne la relativa posizione nell'ordinamento tramite i metodi String seguenti:

  • Compare restituisce un valore intero che indica la relazione tra due stringhe nell'ordinamento.

  • CompareOrdinal restituisce un valore intero che indica la relazione tra due stringhe in base a un confronto dei relativi punti di codice.

  • CompareTo restituisce un valore intero che indica la relazione tra l'istanza della stringa corrente e una seconda stringa nell'ordinamento. Il metodo CompareTo(String) fornisce le implementazioni IComparable e IComparable<T> per la classe String.

s1wwdcbf.collapse_all(it-it,VS.110).gifTest dell'uguaglianza delle stringhe

Per stabilire se due stringhe sono uguali, chiamare il metodo Equals. L'istanza Equals(String, String, StringComparison) e gli overload Equals(String, StringComparison) statici consentono di specificare se il confronto è dipendente dalle impostazioni cultura o ordinale e se le maiuscole e le minuscole vengono rispettate o ignorate. La maggior parte dei test per l'uguaglianza sono ordinali e i confronti per l'uguaglianza che determinano l'accesso a una risorsa di sistema (ad esempio un oggetto del file system) devono essere sempre ordinali.

s1wwdcbf.collapse_all(it-it,VS.110).gifRicerca di caratteri in una stringa

La classe String include due tipi di metodi di ricerca:

Nota di avvisoAttenzione

Se si desidera trovare una stringa per un modello specifico anziché una sotto stringa specifica, utilizzare le espressioni regolari. Per ulteriori informazioni, vedere Espressioni regolari di .NET Framework.

s1wwdcbf.collapse_all(it-it,VS.110).gifModifica di una stringa

La classe String include i metodi seguenti che vengono visualizzati per modificare il valore di una stringa:

  • Insert inserisce una stringa nell'istanza di String corrente.

  • PadLeft consente di inserire una o più occorrenze di un carattere specificato all'inizio di una stringa.

  • PadRight consente di inserire una o più occorrenze di un carattere specificato all'inizio di una stringa.

  • Remove elimina una sottostringa dall'istanza di String corrente.

  • Replace sostituisce una sottostringa con un'altra sottostringa nell'istanza di String corrente.

  • ToLower e ToLowerInvariant convertono tutti i caratteri di una stringa in lettere minuscole.

  • ToUpper e ToUpperInvariant convertono tutti i caratteri di una stringa in lettere maiuscole.

  • Trim rimuove tutte le occorrenze di un carattere dall'inizio e dalla fine di una stringa.

  • TrimEnd rimuove tutte le occorrenze di un carattere dalla fine di una stringa.

  • TrimStart rimuove tutte le occorrenze di un carattere dall'inizio di una stringa.

Nota importanteImportante

Tutti i metodi di modifica delle stringhe restituiscono un nuovo oggetto String. Il valore dell'istanza corrente non viene modificato.

s1wwdcbf.collapse_all(it-it,VS.110).gifEstrazione di sotto stringhe da una stringa

Il metodo String.Split separa una singola stringa in più stringhe. Gli overload del metodo consentono all'utente di specificare più delimitatori per determinare il numero massimo di sottostringhe che il metodo estrae e per determinare se stringhe vuote (presenti quando i delimitatori sono adiacenti) sono incluse tra le stringhe restituite.

s1wwdcbf.collapse_all(it-it,VS.110).gifCombinazione di stringhe

I metodi String seguenti possono essere utilizzati per la concatenazione di stringhe:

  • Concat combina uno o più sottostringhe in una singola stringa.

  • Join concatena uno o più sottostringhe in un solo elemento e aggiunge un separatore tra ogni sottostringa.

s1wwdcbf.collapse_all(it-it,VS.110).gifformattazione di valori

Il metodo String.Format utilizza la funzionalità di formattazione composita per sostituire uno o più segnaposto in una stringa con la rappresentazione di un oggetto o un valore. Il metodo Format viene spesso utilizzato per effettuare le seguenti operazioni:

  • Per incorporare la rappresentazione di stringa di un valore numerico in una stringa.

  • Per incorporare la rappresentazione di stringa di un valore di data e ora in una stringa.

  • Per incorporare la rappresentazione di stringa di un valore di enumerazione in una stringa.

  • Per incorporare la rappresentazione di stringa di un oggetto che supporta l'interfaccia IFormattable in una stringa.

  • Per allineare a destra o a sinistra una sottostringa in un campo all'interno di una stringa più grande.

Per informazioni dettagliate sulle operazioni di formattazione e per esempi, consultare il riepilogo dell'overload Format.

s1wwdcbf.collapse_all(it-it,VS.110).gifCopia di una stringa

È possibile chiamare i seguenti metodi String per eseguire una copia di una stringa:

  • Clone restituisce un riferimento a un oggetto String esistente.

  • Copy crea una copia di una stringa esistente.

  • CopyTo copia una parte di una stringa in una matrice di caratteri.

s1wwdcbf.collapse_all(it-it,VS.110).gifNormalizzazione di una stringa

In Unicode a un singolo carattere possono essere associati più punti di codice. La normalizzazione converte questi caratteri equivalenti nella stessa rappresentazione binaria. Il metodo String.Normalize esegue la normalizzazione e il metodo String.IsNormalized determina se una stringa è normalizzata.

.NET Framework

Supportato in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Supportato in: 4, 3.5 SP1

Libreria di classi portabile

Supportato in: Libreria di classi portabile

.NET per applicazioni Windows Store

Supportato in: Windows 8

.NET per applicazioni Windows Phone

Supportato in: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (ruoli di base del server non supportati), Windows Server 2008 R2 (ruoli di base del server supportati con SP1 o versione successiva, Itanium non supportato)

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

Questo tipo è thread-safe.

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft