Exporter (0) Imprimer
Développer tout
Cet article a fait l'objet d'une traduction automatique. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte. Informations supplémentaires.
Traduction
Source
Ce sujet n'a pas encore été évalué - Évaluez ce sujet

String, classe

Représente du texte sous forme d'une série de caractères Unicode.

Espace de noms :  System
Assembly :  mscorlib (dans mscorlib.dll)
[SerializableAttribute]
[ComVisibleAttribute(true)]
public sealed class String : IComparable, 
	ICloneable, IConvertible, IComparable<string>, IEnumerable<char>, 
	IEnumerable, IEquatable<string>

Le type String expose les membres suivants.

  NomDescription
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreString(Char*)Initialise une nouvelle instance de la classe String à la valeur indiquée par un pointeur spécifié vers un tableau de caractères Unicode.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreString(Char[])Initialise une nouvelle instance de la classe String à la valeur indiquée par un tableau de caractères Unicode.
Méthode publiquePris en charge par XNA FrameworkString(SByte*)Initialise une nouvelle instance de la classe String à la valeur indiquée par un pointeur vers un tableau d'entiers signés 8 bits.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreString(Char, Int32)Initialise une nouvelle instance de la classe String à la valeur indiquée par un caractère Unicode spécifié et répété un certain nombre de fois.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreString(Char*, Int32, Int32)Initialise une nouvelle instance de la classe String à la valeur indiquée par un pointeur spécifié vers un tableau de caractères Unicode, un point de départ pour le caractère dans ce tableau et une longueur.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreString(Char[], Int32, Int32)Initialise une nouvelle instance de la classe String à la valeur indiquée par un tableau de caractères Unicode, un point de départ pour le caractère dans ce tableau et une longueur.
Méthode publiqueString(SByte*, Int32, Int32)Initialise une nouvelle instance de la classe String à la valeur indiquée par un pointeur spécifié vers un tableau d'entiers signés 8 bits, une position de départ dans ce tableau et une longueur.
Méthode publiqueString(SByte*, Int32, Int32, Encoding)Initialise une nouvelle instance de la classe String à la valeur indiquée par un pointeur spécifié vers un tableau d'entiers signés 8 bits, une position de départ dans ce tableau, une longueur et un objet Encoding.
Début
  NomDescription
Propriété publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCharsObtient l'objet Char à une position de caractère spécifiée dans l'objet String en cours.
Propriété publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLengthObtient le nombre de caractères dans l'objet String actuel.
Début
  NomDescription
Méthode publiquePris en charge par XNA FrameworkCloneRetourne une référence à cette instance de String.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCompare(String, String)Compare deux objets String spécifiés et retourne un entier qui indique leur position relative dans l'ordre de tri.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkCompare(String, String, Boolean)Compare deux objets String spécifiés, en ignorant ou en respectant leur casse, et retourne un entier qui indique leur position relative dans l'ordre de tri.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCompare(String, String, StringComparison)Compare deux objets String spécifiés à l'aide des règles désignées et retourne un entier qui indique leur position relative dans l'ordre de tri.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkCompare(String, String, Boolean, CultureInfo)Compare deux objets String spécifiés, en ignorant ou en respectant leur casse et en utilisant les informations propres à la culture pour influencer la comparaison, et retourne un entier qui indique leur position relative dans l'ordre de tri.
Méthode publiqueMembre statiquePris en charge par  Bibliothèque de classes portableCompare(String, String, CultureInfo, CompareOptions)Compare deux objets String spécifiés en utilisant les options de comparaison spécifiées et les informations propres à la culture pour influencer la comparaison, et retourne un entier qui indique la relation entre ces deux chaînes dans l'ordre de tri.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCompare(String, Int32, String, Int32, Int32)Compare les sous-chaînes de deux objets String spécifiés et retourne un entier qui indique leur position relative dans l'ordre de tri.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkCompare(String, Int32, String, Int32, Int32, Boolean)Compare les sous-chaînes de deux objets String spécifiés, en ignorant ou en respectant leur casse, et retourne un entier qui indique leur position relative dans l'ordre de tri.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCompare(String, Int32, String, Int32, Int32, StringComparison)Compare les sous-chaînes de deux objets String spécifiés à l'aide des règles désignées et retourne un entier qui indique leur position relative dans l'ordre de tri.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkCompare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)Compare les sous-chaînes de deux objets String spécifiés, en ignorant ou en respectant leur casse et en utilisant les informations propres à la culture pour influencer la comparaison, et retourne un entier qui indique leur position relative dans l'ordre de tri.
Méthode publiqueMembre statiqueCompare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)Compare des sous-chaînes de deux objets String spécifiés en utilisant les options de comparaison spécifiées et les informations propres à la culture pour influencer la comparaison, et retourne un entier qui indique la relation entre ces deux sous-chaînes dans l'ordre de tri.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCompareOrdinal(String, String)Compare deux objets String spécifiés en évaluant les valeurs numériques des objets Char correspondant dans chaque chaîne.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCompareOrdinal(String, Int32, String, Int32, Int32)Compare les sous-chaînes de deux objets String spécifiés en évaluant les valeurs numériques des objets Char correspondants de chaque sous-chaîne.
Méthode publiquePris en charge par XNA FrameworkCompareTo(Object)Compare cette instance avec un Object spécifié et indique si cette instance précède, suit ou apparaît dans la même position dans l'ordre de tri que le Objectspécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCompareTo(String)Compare cette instance avec un objet String spécifié et indique si cette instance précède, suit ou apparaît dans la même position dans l'ordre de tri que le Stringspécifié.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreConcat(Object)Crée la représentation sous forme de chaîne d'un objet spécifié.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreConcat(Object[])Concatène les représentations sous forme de chaîne des éléments dans un tableau Object spécifié.
Méthode publiqueMembre statiquePris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreConcat(IEnumerable<String>)Concatène les membres d'une collection IEnumerable<T> construite de type String.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreConcat(String[])Concatène les éléments d'un tableau String spécifié.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreConcat(Object, Object)Concatène les représentations sous forme de chaîne de deux objets spécifiés.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreConcat(String, String)Concatène deux instances spécifiées de String.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreConcat(Object, Object, Object)Concatène les représentations sous forme de chaîne de trois objets spécifiés.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreConcat(String, String, String)Concatène trois instances spécifiées de String.
Méthode publiqueMembre statiqueConcat(Object, Object, Object, Object)Concatène les représentations sous forme de chaîne de quatre objets spécifiés et de tous les objets spécifiés dans une liste de paramètres de longueur variable facultative.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreConcat(String, String, String, String)Concatène quatre instances spécifiées de String.
Méthode publiqueMembre statiquePris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreConcat<T>(IEnumerable<T>)Concatène les membres d'une implémentation IEnumerable<T>.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreContainsRetourne une valeur indiquant si une sous-chaîne spécifiée se produit dans cette chaîne.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkCopyCrée une nouvelle instance de String ayant la même valeur qu'un String spécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCopyToCopie un nombre spécifié de caractères à partir d'une position définie dans cette instance vers une position spécifiée dans un tableau de caractères Unicode.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEndsWith(String)Détermine si la fin de cette instance de chaîne correspond à la chaîne spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEndsWith(String, StringComparison)Détermine si la fin de cette instance de chaîne correspond à la chaîne spécifiée lors d'une comparaison à l'aide de l'option spécifiée.
Méthode publiqueEndsWith(String, Boolean, CultureInfo)Détermine si la fin de cette instance de chaîne correspond à la chaîne spécifiée lors d'une comparaison à l'aide de la culture spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEquals(Object)Détermine si cette instance et un objet spécifié, qui doit aussi être un objet String, ont la même valeur. (Substitue Object.Equals(Object).)
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEquals(String)Détermine si cette instance et un autre objet String spécifié ont la même valeur.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEquals(String, String)Détermine si deux objets String spécifiés ont la même valeur.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEquals(String, StringComparison)Détermine si cette chaîne et un objet String spécifié ont la même valeur. Un paramètre spécifie la culture, la casse et les règles de tri utilisées dans la comparaison.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEquals(String, String, StringComparison)Détermine si deux objets String spécifiés ont la même valeur. Un paramètre spécifie la culture, la casse et les règles de tri utilisées dans la comparaison.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkFormat(String, Object)Remplace un ou plusieurs éléments de mise en forme d'une chaîne spécifiée par la représentation sous forme de chaîne d'un objet spécifié.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFormat(String, Object[])Remplace l'élément de mise en forme d'une chaîne spécifiée par la représentation sous forme de chaîne d'un objet correspondant dans un tableau spécifié.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreFormat(IFormatProvider, String, Object[])Remplace les éléments de mise en forme d'une chaîne spécifiée par les représentations sous forme d'objets correspondants dans un tableau spécifié. Un paramètre fournit des informations de format propres à la culture.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkFormat(String, Object, Object)Remplace les éléments de mise en forme dans une chaîne spécifiée par la représentation sous forme de chaîne de deux objets spécifiés.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkFormat(String, Object, Object, Object)Remplace les éléments de mise en forme d'une chaîne spécifiée par la représentation sous forme de chaîne de trois objets spécifiés.
Méthode publiquePris en charge par XNA FrameworkGetEnumeratorRécupère un objet qui peut itérer au sein des caractères individuels de cette chaîne.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetHashCodeRetourne le code de hachage pour cette chaîne. (Substitue Object.GetHashCode().)
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreGetTypeObtient le Type de l'instance actuelle. (Hérité de Object.)
Méthode publiquePris en charge par XNA FrameworkGetTypeCodeRetourne TypeCode pour la classe String.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIndexOf(Char)Signale l'index de base zéro de la première occurrence du caractère Unicode spécifié dans cette chaîne.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIndexOf(String)Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans cette instance.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIndexOf(Char, Int32)Signale l'index de base zéro de la première occurrence du caractère Unicode spécifié dans cette chaîne. La recherche démarre à une position de caractère spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIndexOf(String, Int32)Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans cette instance. La recherche démarre à une position de caractère spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIndexOf(String, StringComparison)Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans l'objet String en cours. Un paramètre spécifie le type de recherche à utiliser pour la chaîne spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIndexOf(Char, Int32, Int32)Signale l'index de base zéro de la première occurrence du caractère spécifié dans cette instance. La recherche commence à une position de caractère spécifiée et examine un nombre défini de positions de caractère.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIndexOf(String, Int32, Int32)Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans cette instance. La recherche commence à une position de caractère spécifiée et examine un nombre défini de positions de caractère.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIndexOf(String, Int32, StringComparison)Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans l'objet String en cours. Les paramètres spécifient la position de recherche initiale dans la chaîne en cours et le type de recherche à utiliser pour la chaîne spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIndexOf(String, Int32, Int32, StringComparison)Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans l'objet String en cours. Les paramètres spécifient la position de recherche initiale dans la chaîne en cours, le nombre de caractères de la chaîne en cours à rechercher et le type de recherche à utiliser pour la chaîne spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIndexOfAny(Char[])Signale l'index de base zéro de la première occurrence dans cette instance de tout caractère dans un tableau de caractères Unicode spécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIndexOfAny(Char[], Int32)Signale l'index de base zéro de la première occurrence dans cette instance de tout caractère dans un tableau de caractères Unicode spécifié. La recherche démarre à une position de caractère spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIndexOfAny(Char[], Int32, Int32)Signale l'index de base zéro de la première occurrence dans cette instance de tout caractère dans un tableau de caractères Unicode spécifié. La recherche commence à une position de caractère spécifiée et examine un nombre défini de positions de caractère.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreInsertRetourne une nouvelle chaîne dans laquelle une chaîne spécifiée est insérée dans cette instance à une position d'index spécifiée.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkInternRécupère la référence du système au String spécifié.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkIsInternedRécupère une référence à un String spécifié.
Méthode publiqueIsNormalized()Indique si cette chaîne se trouve dans un formulaire de normalisation C Unicode.
Méthode publiqueIsNormalized(NormalizationForm)Indique si cette chaîne se trouve dans le formulaire de normalisation Unicode spécifié.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIsNullOrEmptyIndique si la chaîne spécifiée est null ou une chaîne Empty.
Méthode publiqueMembre statiquePris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIsNullOrWhiteSpaceIndique si une chaîne spécifiée est null, vide ou se compose uniquement d'espaces blancs.
Méthode publiqueMembre statiquePris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreJoin(String, IEnumerable<String>)Concatène les membres d'une collection IEnumerable<T> construite de type String, en utilisant le séparateur spécifié entre chaque membre.
Méthode publiqueMembre statiquePris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreJoin(String, Object[])Concatène les éléments d'un tableau d'objets, à l'aide du séparateur spécifié entre chaque élément.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreJoin(String, String[])Concatène tous les éléments d'un tableau de chaînes, en utilisant le séparateur spécifié entre chaque élément.
Méthode publiqueMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreJoin(String, String[], Int32, Int32)Concatène les éléments spécifiés d'un tableau de chaînes, en utilisant le séparateur spécifié entre chaque élément.
Méthode publiqueMembre statiquePris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreJoin<T>(String, IEnumerable<T>)Concatène les membres d'une collection, en utilisant le séparateur spécifié entre chaque membre.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLastIndexOf(Char)Signale la position d'index de base zéro de la dernière occurrence d'un caractère Unicode spécifié dans cette instance.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLastIndexOf(String)Signale la position d'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans cette instance.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLastIndexOf(Char, Int32)Signale la position d'index de base zéro de la dernière occurrence d'un caractère Unicode spécifié dans cette instance. La recherche commence à une position de caractère spécifiée et s'exécute vers l'arrière, vers le début de la chaîne.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLastIndexOf(String, Int32)Signale la position d'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans cette instance. La recherche commence à une position de caractère spécifiée et s'exécute vers l'arrière, vers le début de la chaîne.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLastIndexOf(String, StringComparison)Signale l'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans l'objet String en cours. Un paramètre spécifie le type de recherche à utiliser pour la chaîne spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLastIndexOf(Char, Int32, Int32)Signale la position d'index de base zéro de la dernière occurrence du caractère Unicode spécifié dans une sous-chaîne de cette instance. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne pour un nombre spécifié de positions de caractères.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLastIndexOf(String, Int32, Int32)Signale la position d'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans cette instance. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne pour un nombre spécifié de positions de caractères.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLastIndexOf(String, Int32, StringComparison)Signale l'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans l'objet String en cours. La recherche commence à une position de caractère spécifiée et s'exécute vers l'arrière, vers le début de la chaîne. Paramètre qui spécifie le type de comparaison à effectuer lors de la recherche de la chaîne spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLastIndexOf(String, Int32, Int32, StringComparison)Signale la position d'index de base zéro de la dernière occurrence d'une chaîne spécifiée dans cette instance. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne pour le nombre spécifié de positions de caractères. Paramètre qui spécifie le type de comparaison à effectuer lors de la recherche de la chaîne spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLastIndexOfAny(Char[])Signale la position d'index de base zéro de la dernière occurrence dans cette instance d'un ou plusieurs caractères spécifiés dans un tableau Unicode.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLastIndexOfAny(Char[], Int32)Signale la position d'index de base zéro de la dernière occurrence dans cette instance d'un ou plusieurs caractères spécifiés dans un tableau Unicode. La recherche commence à une position de caractère spécifiée et s'exécute vers l'arrière, vers le début de la chaîne.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreLastIndexOfAny(Char[], Int32, Int32)Signale la position d'index de base zéro de la dernière occurrence dans cette instance d'un ou plusieurs caractères spécifiés dans un tableau Unicode. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne pour un nombre spécifié de positions de caractères.
Méthode publiqueNormalize() Retourne une nouvelle chaîne dont la valeur textuelle est la même que celle de cette chaîne, mais dont la représentation binaire correspond à la forme de normalisation Unicode C.
Méthode publiqueNormalize(NormalizationForm)Retourne une nouvelle chaîne dont la valeur textuelle est identique à celle de cette chaîne, mais dont la représentation binaire se trouve dans le formulaire de normalisation Unicode spécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StorePadLeft(Int32)Retourne une nouvelle chaîne qui aligne les caractères de cette instance à droite en les complétant par des espaces à gauche pour une longueur totale spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StorePadLeft(Int32, Char)Retourne une nouvelle chaîne qui aligne les caractères de cette instance à droite en les complétant par un caractère Unicode spécifié à gauche pour une longueur totale spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StorePadRight(Int32)Retourne une nouvelle chaîne qui aligne les caractères de cette chaîne à gauche en les complétant par des espaces à droite pour une longueur totale spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StorePadRight(Int32, Char)Retourne une nouvelle chaîne qui aligne les caractères de cette chaîne à gauche en les complétant par un caractère Unicode spécifié à droite pour une longueur totale spécifiée.
Méthode publiquePris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreRemove(Int32)Retourne une nouvelle chaîne dans laquelle tous les caractères de l'instance actuelle ont été supprimés à partir d'une position spécifiée et jusqu'à la dernière position.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreRemove(Int32, Int32)Retourne une nouvelle chaîne dans laquelle un nombre de caractères spécifié ont été supprimés dans l'instance active en commençant à une position spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreReplace(Char, Char)Retourne une nouvelle chaîne dans laquelle toutes les occurrences d'un caractère Unicode spécifié dans cette instance sont remplacées par un autre caractère Unicode spécifié.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreReplace(String, String)Retourne une nouvelle chaîne dans laquelle toutes les occurrences d'une chaîne spécifiée dans l'instance actuelle sont remplacées par une autre chaîne spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSplit(Char[])Retourne un tableau de chaînes qui contient les sous-chaînes de cette instance, délimitées par les éléments d'un tableau de caractères Unicode spécifié.
Méthode publiquePris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSplit(Char[], Int32)Retourne un tableau de chaînes qui contient les sous-chaînes de cette instance, délimitées par les éléments d'un tableau de caractères Unicode spécifié. Un paramètre spécifie le nombre maximal de sous-chaînes à retourner.
Méthode publiquePris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSplit(Char[], StringSplitOptions)Retourne un tableau de chaînes qui contient les sous-chaînes de cette chaîne, délimitées par les éléments d'un tableau de caractères Unicode spécifié. Un paramètre spécifie s'il faut retourner les éléments de tableau vides.
Méthode publiquePris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSplit(String[], StringSplitOptions)Retourne un tableau de chaînes qui contient les sous-chaînes de cette chaîne, délimitées par les éléments d'un tableau de chaînes spécifié. Un paramètre spécifie s'il faut retourner les éléments de tableau vides.
Méthode publiquePris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSplit(Char[], Int32, StringSplitOptions)Retourne un tableau de chaînes qui contient les sous-chaînes de cette chaîne, délimitées par les éléments d'un tableau de caractères Unicode spécifié. Les paramètres spécifient le nombre maximal de sous-chaînes à retourner et s'il faut retourner les éléments d'un tableau vides.
Méthode publiquePris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSplit(String[], Int32, StringSplitOptions)Retourne un tableau de chaînes qui contient les sous-chaînes de cette chaîne, délimitées par les éléments d'un tableau de chaînes spécifié. Les paramètres spécifient le nombre maximal de sous-chaînes à retourner et s'il faut retourner les éléments d'un tableau vides.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreStartsWith(String)Détermine si le début de cette instance de chaîne correspond à la chaîne spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreStartsWith(String, StringComparison)Détermine si le début de cette instance de chaîne correspond à la chaîne spécifiée lors d'une comparaison à l'aide de l'option spécifiée.
Méthode publiqueStartsWith(String, Boolean, CultureInfo)Détermine si le début de cette instance de chaîne correspond à la chaîne spécifiée lors d'une comparaison à l'aide de la culture spécifiée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSubstring(Int32)Récupère une sous-chaîne de cette instance. La sous-chaîne commence à une position de caractère spécifiée et continue jusqu'à la fin de la chaîne.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreSubstring(Int32, Int32)Récupère une sous-chaîne de cette instance. La sous-chaîne démarre à une position de caractère spécifiée et a une longueur définie.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToCharArray()Copie les caractères dans cette instance vers un tableau de caractères Unicode.
Méthode publiquePris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToCharArray(Int32, Int32)Copie les caractères dans une sous-chaîne spécifiée de cette instance vers un tableau de caractères Unicode.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToLower()Retourne une copie de cette chaîne convertie en minuscules.
Méthode publiquePris en charge par XNA FrameworkToLower(CultureInfo)Retourne une copie de cette chaîne en minuscules, à l'aide des règles se rapportant à la casse pour la culture spécifiée.
Méthode publiquePris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToLowerInvariantRetourne une copie de cet objet String converti en minuscules à l'aide des règles de la culture dite indifférente se rapportant à la casse.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToString()Retourne cette instance de String ; aucune conversion n'est effectivement effectuée. (Substitue Object.ToString().)
Méthode publiquePris en charge par XNA FrameworkToString(IFormatProvider)Retourne cette instance de String ; aucune conversion n'est effectivement effectuée.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToUpper()Retourne une copie de cette chaîne convertie en majuscules.
Méthode publiquePris en charge par XNA FrameworkToUpper(CultureInfo)Retourne une copie de cette chaîne en majuscules, à l'aide des règles se rapportant à la casse pour la culture spécifiée.
Méthode publiquePris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreToUpperInvariantRetourne une copie de cet objet String converti en majuscules à l'aide des règles de la culture dite indifférente se rapportant à la casse.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreTrim()Supprime, de l'objet String actuel, tous les espaces blancs en début ou en fin de chaîne.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreTrim(Char[])Supprime, de l'objet String actuel, toutes les occurrences situées au début et à la fin d'un jeu de caractères spécifiés dans un tableau.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreTrimEndSupprime, de l'objet String actuel, toutes les occurrences situées à la fin d'un jeu de caractères spécifiés dans un tableau.
Méthode publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreTrimStartSupprime, de l'objet String actuel, toutes les occurrences situées au début d'un jeu de caractères spécifiés dans un tableau.
Début
  NomDescription
Opérateur publicMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEqualityDétermine si deux chaînes spécifiées ont la même valeur.
Opérateur publicMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreInequalityDétermine si deux chaînes spécifiées ont des valeurs différentes.
Début
  NomDescription
Méthode d'extension publiquePris en charge par XNA FrameworkAggregate<Char>(Func<Char, Char, Char>)Surchargé. Applique une fonction d'accumulation sur une séquence. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkAggregate<Char, TAccumulate>(TAccumulate, Func<TAccumulate, Char, TAccumulate>)Surchargé. Applique une fonction d'accumulation sur une séquence. La valeur initiale spécifiée est utilisée comme valeur d'accumulation initiale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkAggregate<Char, TAccumulate, TResult>(TAccumulate, Func<TAccumulate, Char, TAccumulate>, Func<TAccumulate, TResult>)Surchargé. Applique une fonction d'accumulation sur une séquence. La valeur initiale spécifiée est utilisée comme valeur d'accumulation initiale et la fonction spécifiée permet de sélectionner la valeur de résultat. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkAll<Char>Détermine si tous les éléments d'une séquence satisfont à une condition. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkAny<Char>()Surchargé. Détermine si une séquence contient des éléments. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkAny<Char>(Func<Char, Boolean>)Surchargé. Détermine si des éléments d'une séquence satisfont à une condition. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkAsEnumerable<Char>Retourne l'entrée typée comme IEnumerable<T>. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAsParallel()Surchargé. Active la parallélisation d'une requête. (Défini par ParallelEnumerable.)
Méthode d'extension publiqueAsParallel<Char>()Surchargé. Active la parallélisation d'une requête. (Défini par ParallelEnumerable.)
Méthode d'extension publiquePris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreAsQueryable()Surchargé. Convertit un IEnumerable en IQueryable. (Défini par Queryable.)
Méthode d'extension publiqueAsQueryable<Char>()Surchargé. Convertit un IEnumerable<T> générique en IQueryable<T> générique. (Défini par Queryable.)
Méthode d'extension publiquePris en charge par XNA FrameworkAverage<Char>(Func<Char, Int32>)Surchargé. Calcule la moyenne d'une séquence de valeurs Int32 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkAverage<Char>(Func<Char, Nullable<Int32>>)Surchargé. Calcule la moyenne d'une séquence de valeurs Int32 nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkAverage<Char>(Func<Char, Int64>)Surchargé. Calcule la moyenne d'une séquence de valeurs Int64 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkAverage<Char>(Func<Char, Nullable<Int64>>)Surchargé. Calcule la moyenne d'une séquence de valeurs Int64 nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkAverage<Char>(Func<Char, Single>)Surchargé. Calcule la moyenne d'une séquence de valeurs Single obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkAverage<Char>(Func<Char, Nullable<Single>>)Surchargé. Calcule la moyenne d'une séquence de valeurs Single nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkAverage<Char>(Func<Char, Double>)Surchargé. Calcule la moyenne d'une séquence de valeurs Double obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkAverage<Char>(Func<Char, Nullable<Double>>)Surchargé. Calcule la moyenne d'une séquence de valeurs Double nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkAverage<Char>(Func<Char, Decimal>)Surchargé. Calcule la moyenne d'une séquence de valeurs Decimal obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkAverage<Char>(Func<Char, Nullable<Decimal>>)Surchargé. Calcule la moyenne d'une séquence de valeurs Decimal nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreCast<TResult>Effectue un cast des éléments d'un IEnumerable vers le type spécifié. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkConcat<Char>Concatène deux séquences. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkContains<Char>(Char)Surchargé. Détermine si une séquence contient un élément spécifié à l'aide du comparateur d'égalité par défaut. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkContains<Char>(Char, IEqualityComparer<Char>)Surchargé. Détermine si une séquence contient un élément spécifié à l'aide du IEqualityComparer<T> indiqué. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkCount<Char>()Surchargé. Retourne le nombre total d'éléments dans une séquence. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkCount<Char>(Func<Char, Boolean>)Surchargé. Retourne un nombre qui représente les éléments de la séquence spécifiée qui satisfont à une condition. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkDefaultIfEmpty<Char>()Surchargé. Retourne les éléments de la séquence spécifiée ou la valeur par défaut du paramètre de type dans une collection de singletons si la séquence est vide. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkDefaultIfEmpty<Char>(Char)Surchargé. Retourne les éléments de la séquence spécifiée ou la valeur indiquée dans une collection de singletons si la séquence est vide. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkDistinct<Char>()Surchargé. Retourne des éléments distincts d'une séquence et utilise le comparateur d'égalité par défaut pour comparer les valeurs. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkDistinct<Char>(IEqualityComparer<Char>)Surchargé. Retourne des éléments distincts d'une séquence et utilise le IEqualityComparer<T> spécifié pour comparer les valeurs. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkElementAt<Char>Retourne l'élément à une position d'index spécifiée dans une séquence. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkElementAtOrDefault<Char>Retourne l'élément situé à un index spécifié dans une séquence ou une valeur par défaut si l'index est hors limites. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkExcept<Char>(IEnumerable<Char>)Surchargé. Produit la différence entre deux séquences à l'aide du comparateur d'égalité par défaut pour comparer les valeurs. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkExcept<Char>(IEnumerable<Char>, IEqualityComparer<Char>)Surchargé. Produit la différence entre deux séquences à l'aide du IEqualityComparer<T> spécifié pour comparer les valeurs. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkFirst<Char>()Surchargé. Retourne le premier élément d'une séquence. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkFirst<Char>(Func<Char, Boolean>)Surchargé. Retourne le premier élément d'une séquence à satisfaire à la condition spécifiée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkFirstOrDefault<Char>()Surchargé. Retourne le premier élément d'une séquence ou une valeur par défaut si la séquence ne contient aucun élément. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkFirstOrDefault<Char>(Func<Char, Boolean>)Surchargé. Retourne le premier élément de la séquence à satisfaire à une condition ou une valeur par défaut si aucun élément correspondant n'est trouvé. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkGroupBy<Char, TKey>(Func<Char, TKey>)Surchargé. Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkGroupBy<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)Surchargé. Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et compare les clés à l'aide du comparateur indiqué. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkGroupBy<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)Surchargé. Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et projette les éléments de chaque groupe à l'aide de la fonction indiquée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkGroupBy<Char, TKey, TResult>(Func<Char, TKey>, Func<TKey, IEnumerable<Char>, TResult>)Surchargé. Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et crée une valeur de résultat à partir de chaque groupe et de la clé correspondante. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkGroupBy<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)Surchargé. Regroupe les éléments d'une séquence selon une fonction de sélection de clé. Les clés sont comparées à l'aide d'un comparateur et les éléments de chaque groupe sont projetés à l'aide d'une fonction spécifique. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkGroupBy<Char, TKey, TResult>(Func<Char, TKey>, Func<TKey, IEnumerable<Char>, TResult>, IEqualityComparer<TKey>)Surchargé. Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et crée une valeur de résultat à partir de chaque groupe et de la clé correspondante. Les clés sont comparées à l'aide d'un comparateur spécifié. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkGroupBy<Char, TKey, TElement, TResult>(Func<Char, TKey>, Func<Char, TElement>, Func<TKey, IEnumerable<TElement>, TResult>)Surchargé. Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et crée une valeur de résultat à partir de chaque groupe et de la clé correspondante. Les éléments de chaque groupe sont projetés à l'aide d'une fonction spécifique. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkGroupBy<Char, TKey, TElement, TResult>(Func<Char, TKey>, Func<Char, TElement>, Func<TKey, IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)Surchargé. Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et crée une valeur de résultat à partir de chaque groupe et de la clé correspondante. Les valeurs de clé sont comparées à l'aide du comparateur spécifié et les éléments de chaque groupe sont projetés à l'aide d'une fonction spécifique. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkGroupJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, IEnumerable<TInner>, TResult>)Surchargé. Met en corrélation les éléments de deux séquences en fonction de l'égalité des clés et regroupe les résultats. Le comparateur d'égalité par défaut est utilisé pour comparer les clés. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkGroupJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)Surchargé. Met en corrélation les éléments de deux séquences en fonction de l'égalité des clés et regroupe les résultats. Un IEqualityComparer<T> spécifié est utilisé pour comparer les clés. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkIntersect<Char>(IEnumerable<Char>)Surchargé. Produit l'intersection de deux séquences à l'aide du comparateur d'égalité par défaut pour comparer les valeurs. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkIntersect<Char>(IEnumerable<Char>, IEqualityComparer<Char>)Surchargé. Produit l'intersection entre deux séquences à l'aide du IEqualityComparer<T> spécifié pour comparer les valeurs. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, TInner, TResult>)Surchargé. Met en corrélation les éléments de deux séquences en fonction des clés qui correspondent. Le comparateur d'égalité par défaut est utilisé pour comparer les clés. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkJoin<Char, TInner, TKey, TResult>(IEnumerable<TInner>, Func<Char, TKey>, Func<TInner, TKey>, Func<Char, TInner, TResult>, IEqualityComparer<TKey>)Surchargé. Met en corrélation les éléments de deux séquences en fonction des clés qui correspondent. Un IEqualityComparer<T> spécifié est utilisé pour comparer les clés. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkLast<Char>()Surchargé. Retourne le dernier élément d'une séquence. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkLast<Char>(Func<Char, Boolean>)Surchargé. Retourne le dernier élément d'une séquence à satisfaire à la condition spécifiée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkLastOrDefault<Char>()Surchargé. Retourne le dernier élément d'une séquence ou une valeur par défaut si la séquence ne contient aucun élément. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkLastOrDefault<Char>(Func<Char, Boolean>)Surchargé. Retourne le dernier élément d'une séquence à satisfaire à une condition ou une valeur par défaut si aucun élément correspondant n'est trouvé. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkLongCount<Char>()Surchargé. Retourne un Int64 qui représente le nombre total d'éléments dans une séquence. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkLongCount<Char>(Func<Char, Boolean>)Surchargé. Retourne un Int64 qui représente le nombre total d'éléments dans une séquence à satisfaire à une condition. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMax<Char>()Surchargé. Retourne la valeur maximale dans une séquence générique. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMax<Char>(Func<Char, Int32>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int32 maximale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMax<Char>(Func<Char, Nullable<Int32>>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int32 nullable maximale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMax<Char>(Func<Char, Int64>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int64 maximale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMax<Char>(Func<Char, Nullable<Int64>>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int64 nullable maximale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMax<Char>(Func<Char, Single>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Single maximale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMax<Char>(Func<Char, Nullable<Single>>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Single nullable maximale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMax<Char>(Func<Char, Double>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Double maximale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMax<Char>(Func<Char, Nullable<Double>>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Double nullable maximale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMax<Char>(Func<Char, Decimal>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Decimal maximale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMax<Char>(Func<Char, Nullable<Decimal>>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Decimal nullable maximale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMax<Char, TResult>(Func<Char, TResult>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence générique et retourne la valeur résultante maximale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMin<Char>()Surchargé. Retourne la valeur minimale dans une séquence générique. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMin<Char>(Func<Char, Int32>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int32 minimale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMin<Char>(Func<Char, Nullable<Int32>>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int32 nullable minimale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMin<Char>(Func<Char, Int64>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int64 minimale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMin<Char>(Func<Char, Nullable<Int64>>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int64 nullable minimale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMin<Char>(Func<Char, Single>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Single minimale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMin<Char>(Func<Char, Nullable<Single>>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Single nullable minimale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMin<Char>(Func<Char, Double>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Double minimale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMin<Char>(Func<Char, Nullable<Double>>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Double nullable minimale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMin<Char>(Func<Char, Decimal>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Decimal minimale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMin<Char>(Func<Char, Nullable<Decimal>>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Decimal nullable minimale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkMin<Char, TResult>(Func<Char, TResult>)Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence générique et retourne la valeur résultante minimale. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreOfType<TResult>Filtre les éléments d'un IEnumerable en fonction du type spécifié. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkOrderBy<Char, TKey>(Func<Char, TKey>)Surchargé. Trie les éléments d'une séquence dans l'ordre croissant selon une clé. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkOrderBy<Char, TKey>(Func<Char, TKey>, IComparer<TKey>)Surchargé. Trie les éléments d'une séquence dans l'ordre croissant à l'aide d'un comparateur spécifié. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkOrderByDescending<Char, TKey>(Func<Char, TKey>)Surchargé. Trie les éléments d'une séquence dans l'ordre décroissant selon une clé. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkOrderByDescending<Char, TKey>(Func<Char, TKey>, IComparer<TKey>)Surchargé. Trie les éléments d'une séquence dans l'ordre décroissant à l'aide d'un comparateur spécifié. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkReverse<Char>Inverse l'ordre des éléments dans une séquence. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSelect<Char, TResult>(Func<Char, TResult>)Surchargé. Projette chaque élément d'une séquence dans un nouveau formulaire. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSelect<Char, TResult>(Func<Char, Int32, TResult>)Surchargé. Projette chaque élément d'une séquence dans un nouveau formulaire en incorporant l'index de l'élément. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSelectMany<Char, TResult>(Func<Char, IEnumerable<TResult>>)Surchargé. Projette chaque élément d'une séquence sur un IEnumerable<T> et aplatit les séquences résultantes en une seule séquence. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSelectMany<Char, TResult>(Func<Char, Int32, IEnumerable<TResult>>)Surchargé. Projette chaque élément d'une séquence sur un IEnumerable<T> et aplatit les séquences résultantes en une seule séquence. L'index de chaque élément source est utilisé dans le formulaire projeté de l'élément. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSelectMany<Char, TCollection, TResult>(Func<Char, Int32, IEnumerable<TCollection>>, Func<Char, TCollection, TResult>)Surchargé. Projette chaque élément d'une séquence sur un IEnumerable<T>, aplatit les séquences résultantes en une seule séquence et appelle une fonction de sélection de résultat sur chaque élément inclus. L'index de chaque élément source est utilisé dans le formulaire intermédiaire projeté de l'élément. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSelectMany<Char, TCollection, TResult>(Func<Char, IEnumerable<TCollection>>, Func<Char, TCollection, TResult>)Surchargé. Projette chaque élément d'une séquence sur un IEnumerable<T>, aplatit les séquences résultantes en une seule séquence et appelle une fonction de sélection de résultat sur chaque élément inclus. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSequenceEqual<Char>(IEnumerable<Char>)Surchargé. Détermine si deux séquences sont égales par une comparaison des types d'élément réalisée à l'aide du comparateur d'égalité par défaut. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSequenceEqual<Char>(IEnumerable<Char>, IEqualityComparer<Char>)Surchargé. Détermine si deux séquences sont égales en comparant leurs éléments à l'aide d'un IEqualityComparer<T> spécifié. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSingle<Char>()Surchargé. Retourne l'élément unique d'une séquence ou lève une exception si cette séquence ne contient pas un seul élément. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSingle<Char>(Func<Char, Boolean>)Surchargé. Retourne le seul élément d'une séquence qui satisfait à une condition spécifique ou lève une exception si cette séquence contient plusieurs éléments respectant cette condition. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSingleOrDefault<Char>()Surchargé. Retourne l'élément unique d'une séquence ou une valeur par défaut. Cette méthode lève une exception si cette séquence contient plusieurs éléments. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSingleOrDefault<Char>(Func<Char, Boolean>)Surchargé. Retourne l'élément unique d'une séquence ou une valeur par défaut si cette séquence ne contient pas d'élément respectant cette condition. Cette méthode lève une exception si cette séquence contient plusieurs éléments satisfaisant à cette condition. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSkip<Char>Ignore un nombre spécifié d'éléments dans une séquence puis retourne les éléments restants. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSkipWhile<Char>(Func<Char, Boolean>)Surchargé. Ignore des éléments dans une séquence tant que la condition spécifiée a la valeur true, puis retourne les éléments restants. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSkipWhile<Char>(Func<Char, Int32, Boolean>)Surchargé. Ignore des éléments dans une séquence tant que la condition spécifiée a la valeur true, puis retourne les éléments restants. L'index de l'élément est utilisé dans la logique de la fonction de prédicat. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSum<Char>(Func<Char, Int32>)Surchargé. Calcule la somme d'une séquence de valeurs Int32 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSum<Char>(Func<Char, Nullable<Int32>>)Surchargé. Calcule la somme d'une séquence de valeurs Int32 nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSum<Char>(Func<Char, Int64>)Surchargé. Calcule la somme d'une séquence de valeurs Int64 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSum<Char>(Func<Char, Nullable<Int64>>)Surchargé. Calcule la somme d'une séquence de valeurs Int64 nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSum<Char>(Func<Char, Single>)Surchargé. Calcule la somme d'une séquence de valeurs Single obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSum<Char>(Func<Char, Nullable<Single>>)Surchargé. Calcule la somme d'une séquence de valeurs Single nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSum<Char>(Func<Char, Double>)Surchargé. Calcule la somme d'une séquence de valeurs Double obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSum<Char>(Func<Char, Nullable<Double>>)Surchargé. Calcule la somme d'une séquence de valeurs Double nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSum<Char>(Func<Char, Decimal>)Surchargé. Calcule la somme d'une séquence de valeurs Decimal obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkSum<Char>(Func<Char, Nullable<Decimal>>)Surchargé. Calcule la somme d'une séquence de valeurs Decimal nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkTake<Char>Retourne un nombre spécifié d'éléments contigus à partir du début d'une séquence. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkTakeWhile<Char>(Func<Char, Boolean>)Surchargé. Retourne des éléments d'une séquence tant que la condition spécifiée a la valeur true. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkTakeWhile<Char>(Func<Char, Int32, Boolean>)Surchargé. Retourne des éléments d'une séquence tant que la condition spécifiée a la valeur true. L'index de l'élément est utilisé dans la logique de la fonction de prédicat. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkToArray<Char>Crée un tableau à partir de IEnumerable<T>. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkToDictionary<Char, TKey>(Func<Char, TKey>)Surchargé. Crée un Dictionary<TKey, TValue> à partir d'un IEnumerable<T> selon une fonction de sélection de clé spécifiée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkToDictionary<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)Surchargé. Crée un Dictionary<TKey, TValue> à partir de IEnumerable<T> selon une fonction de sélection de clé spécifiée et un comparateur de clé. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkToDictionary<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)Surchargé. Crée un Dictionary<TKey, TValue> à partir de IEnumerable<T> selon des fonctions de sélection de clé et de sélection d'élément spécifiées. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkToDictionary<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)Surchargé. Crée un Dictionary<TKey, TValue> à partir de IEnumerable<T> selon une fonction de sélection de clé spécifiée, un comparateur et une fonction de sélection d'élément. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkToList<Char>Crée un List<T> à partir de IEnumerable<T>. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkToLookup<Char, TKey>(Func<Char, TKey>)Surchargé. Crée une Lookup<TKey, TElement> à partir de IEnumerable<T> selon une fonction de sélection de clé spécifiée. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkToLookup<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)Surchargé. Crée un Lookup<TKey, TElement> à partir de IEnumerable<T> selon une fonction de sélection de clé spécifiée et un comparateur de clé. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkToLookup<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)Surchargé. Crée un Lookup<TKey, TElement> à partir de IEnumerable<T> selon des fonctions de sélection de clé et de sélection d'élément spécifiées. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkToLookup<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)Surchargé. Crée une Lookup<TKey, TElement> à partir de IEnumerable<T> selon une fonction de sélection de clé spécifiée, un comparateur et une fonction de sélection d'élément. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkUnion<Char>(IEnumerable<Char>)Surchargé. Produit l'union de deux séquences à l'aide du comparateur d'égalité par défaut. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkUnion<Char>(IEnumerable<Char>, IEqualityComparer<Char>)Surchargé. Produit l'union de deux séquences à l'aide d'un IEqualityComparer<T> spécifié. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkWhere<Char>(Func<Char, Boolean>)Surchargé. Filtre une séquence de valeurs selon un prédicat. (Défini par Enumerable.)
Méthode d'extension publiquePris en charge par XNA FrameworkWhere<Char>(Func<Char, Int32, Boolean>)Surchargé. Filtre une séquence de valeurs selon un prédicat. L'index de chaque élément est utilisé dans la logique de la fonction de prédicat. (Défini par Enumerable.)
Méthode d'extension publiqueZip<Char, TSecond, TResult>Applique une fonction spécifiée aux éléments correspondants de deux séquences pour produire une séquence des résultats. (Défini par Enumerable.)
Début
  NomDescription
Champ publicMembre statiquePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreEmptyReprésente la chaîne vide. Ce champ est en lecture seule.
Début
  NomDescription
Implémentation d'interface expliciteMéthode privéePris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIComparable.CompareToCompare l'instance actuelle avec un autre objet du même type et retourne un entier qui indique si l'instance actuelle précède ou suit un autre objet ou se trouve à la même position dans l'ordre de tri.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToBooleanInfrastructure. Pour obtenir une description de ce membre, consultez ToBoolean.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToByteInfrastructure. Pour obtenir une description de ce membre, consultez ToByte.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToCharInfrastructure. Pour obtenir une description de ce membre, consultez ToChar.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToDateTimeInfrastructure. Pour obtenir une description de ce membre, consultez ToDateTime.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToDecimalInfrastructure. Pour obtenir une description de ce membre, consultez ToDecimal.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToDoubleInfrastructure. Pour obtenir une description de ce membre, consultez ToDouble.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToInt16Infrastructure. Pour obtenir une description de ce membre, consultez ToInt16.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToInt32Infrastructure. Pour obtenir une description de ce membre, consultez ToInt32.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToInt64Infrastructure. Pour obtenir une description de ce membre, consultez ToInt64.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToSByteInfrastructure. Pour obtenir une description de ce membre, consultez ToSByte.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToSingleInfrastructure. Pour obtenir une description de ce membre, consultez ToSingle.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToTypeInfrastructure. Pour obtenir une description de ce membre, consultez ToType.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToUInt16Infrastructure. Pour obtenir une description de ce membre, consultez ToUInt16.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToUInt32Infrastructure. Pour obtenir une description de ce membre, consultez ToUInt32.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIConvertible.ToUInt64Infrastructure. Pour obtenir une description de ce membre, consultez ToUInt64.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkIEnumerable<Char>.GetEnumeratorRetourne un énumérateur qui itère au sein de l'objet String actuel.
Implémentation d'interface expliciteMéthode privéePris en charge par XNA FrameworkPris en charge par  Bibliothèque de classes portablePris en charge dans .NET pour les applications du Windows StoreIEnumerable.GetEnumeratorRetourne un énumérateur qui itère au sein de l'objet String actuel.
Début

Une chaîne est une collection séquentielle de caractères Unicode utilisée pour représenter du texte. Un objet String est une collection séquentielle d'objets System.Char représentant une chaîne. La valeur de l'objet String correspond au contenu de la collection séquentielle et elle est immuable (c'est-à-dire, elle est en lecture seule). Pour plus d'informations sur l'immuabilité de chaînes, consultez la section Immuabilité et la classe StringBuilder plus loin dans cette rubrique. La taille maximale d'un objet String de la mémoire est de 2 Go, ou environ 1 milliard de caractères.

Dans cette section :

Instanciation d'un objet String
Objets et caractères Unicode char
Chaînes et caractères Null incorporés
Chaînes et index
Chaînes null et chaînes vides
Immuabilité et la classe StringBuilder
Nombre ordinal les des opérations dépendantes de la culture
Normalisation
Opérations de chaîne par catégorie

Instanciation d'un objet String

Vous pouvez instancier un objet String des façons suivantes :

  • En assignant un littéral de chaîne à une variable String. C'est la méthode le plus communément utilisée pour la création d'une chaîne. L'exemple suivant utilise l'assignation pour créer plusieurs chaînes. Notez qu'en C#, étant donné que la barre oblique inverse (\) est un caractère d'échappement, des barres obliques inverses littérales dans une chaîne doivent être évitées ou la chaîne entière doit être placée entre deux caractères @.

    
    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      
    
    
    
  • En appelant un constructeur de classe String. L'exemple suivant instancie des chaînes en appelant plusieurs constructeurs de classe. Notez que certains constructeurs incluent des pointeurs vers des tableaux de caractères ou des tableaux d'octets signés comme paramètres. Visual Basic ne prend pas en charge les appels à ces constructeurs. Pour plus d'informations sur les constructeurs String, consultez le résumé de constructeur 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  
    
    
    
  • En utilisant l'opérateur de concaténation de chaînes (+ en C# et & ou + en Visual Basic) pour créer une chaîne unique à partir de toute combinaison d'instances String et de littéraux de chaîne. L'exemple ci-dessous illustre l'utilisation de l'opérateur de concaténation de chaînes.

    
    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.
    
    
    
  • En extrayant une propriété ou en appelant une méthode qui retourne une chaîne. L'exemple suivant utilise les méthodes de la classe String pour extraire une sous-chaîne d'une plus grande chaîne.

    
    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
    
    
    
  • En appelant une méthode de mise en forme pour convertir une valeur ou un objet en sa représentation sous forme de chaîne. L'exemple suivant utilise la fonctionnalité d'mise en forme composite pour inclure la représentation sous forme de chaîne de deux objets dans une chaîne.

    
    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.      
    
    
    

Objets et caractères Unicode char

Chaque caractère d'une chaîne est défini par une valeur scalaire Unicode, également appelée point de code Unicode ou valeur ordinale (numérique) du caractère Unicode. Chaque point de code est encodé à l'aide de l'encodage UTF-16 et la valeur numérique de chaque élément de l'encodage est représentée par un objet Char.

En général, un objet Char unique représente un point de code unique ; autrement dit, la valeur numérique de Char est égale au point de code. Par exemple, le point de code du caractère "a" est U+0061. Toutefois, un point de code peut requérir plusieurs éléments encodés (plusieurs objets Char). La norme Unicode définit trois types des caractères qui correspondent à plusieurs objets Char : graphèmes, points de code supplémentaires Unicode et caractères dans les plans supplémentaires.

  • Un graphème est représenté par un caractère de base suivi par un ou plusieurs caractères d'association. Par exemple, le caractère ä est représenté par un objet Char dont le point de code est U+0061, suivi par un objet Char dont le point de code est U+0308. Ce caractère a peut-être été également défini par un seul objet Char qui a un point de code U+00E4. Comme l'indique l'exemple suivant, une comparaison d'égalité dépendante de la culture indique que ces deux représentations sont égales, contrairement à une comparaison ordinale ordinaire. Toutefois, si les deux chaînes sont normalisées, une comparaison ordinale indique également qu'elles sont égales. (Pour plus d'informations sur la normalisation des chaînes, consultez la section Normalisation .)

    
    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 point de code supplémentaire Unicode (une paire de substitution) est représenté par un objet Char dont le point de code est un substitut étendu suivi par un objet Char dont le point de code est un substitut faible. Les unités de code de substituts étendus s'étendent de U+D800 à U+DBFF. Les unités de code de substituts faibles s'étendent U+DC00 et U+DFFF U+DFFF. Les paires de substitution sont utilisées pour représenter les caractères dans des plans supplémentaires de 16 Unicode. L'exemple suivant crée un caractère de substitution et le passe à la méthode Char.IsSurrogatePair(Char, Char) pour déterminer s'il s'agit d'une paire de substitution.

    
    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
    
    
    

Chaînes et caractères Null incorporés

Dans le .NET Framework, un objet String peut inclure des caractères null incorporés, qui comptent dans la longueur de la chaîne. Toutefois, dans certains langages tels que C et C++, un caractère null indique la fin d'une chaîne ; ce n'est pas considéré comme faisant partie de la chaîne et n'est pas compté dans la longueur de la chaîne. Cela signifie que les hypothèses courantes suivantes, que les programmeurs C et C++ ou que les bibliothèques écrites en C ou C++ peuvent soulever à propos des chaînes, ne sont pas nécessairement vraies lorsqu'elles sont appliquées aux objets String :

  • La valeur retournée par les fonctions strlen ou wcslen n'est pas nécessairement égale à la String.Length.

  • La chaîne créée par les fonctions strcpy_s ou wcscpy_s n'est pas nécessairement identique à la chaîne créée par la méthode String.Copy.

Vous devez vous assurer que le code C et C++ natif qui instancie des objets String et le code auquel des objets String sont passés à travers un appel de code non managé, ne supposent pas qu'un caractère null incorporé marque la fin de la chaîne.

Les caractères Null incorporés dans une chaîne sont également traités différemment lorsque cette chaîne est triée (ou comparée) et lorsqu'elle est recherchée. Les caractères Null sont ignorés lors de l'exécution de comparaisons dépendantes de la culture entre deux chaînes, notamment les comparaisons à l'aide de la culture dite indifférente. Ils sont considérés uniquement pour les comparaisons ordinales ou les comparaisons ordinales ne respectant pas la casse. En revanche, les caractères Null incorporés sont toujours considérés lors de la recherche d'une chaîne avec des méthodes telles que Contains, StartsWith et IndexOf.

Chaînes et index

Un index définit la position d'un objet Char (et non d'un caractère Unicode) dans un String. Un index est un nombre non négatif de base zéro qui commence à la première position dans la chaîne, ce qui correspond à la position d'index zéro. Plusieurs méthodes de recherche, telles que IndexOf et LastIndexOf, retournent l'index d'un caractère ou d'une sous-chaîne dans l'instance de chaîne.

La propriété Chars vous permet d'accéder aux objets Char individuels en fonction de leur position d'index dans la chaîne. Étant donné que la propriété Chars est la propriété par défaut (en Visual Basic) ou l'indexeur (en C#), vous pouvez accéder aux objets Char individuels dans une chaîne en utilisant du code similaire au code suivant. Ce code recherche des espaces blancs ou des caractères de ponctuation dans une chaîne pour déterminer le nombre de mots que la chaîne contient.


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.


Étant donné que la classe String implémente l'interface IEnumerable, vous pouvez également itérer au sein des objets Char d'une chaîne à l'aide d'une construction foreach, comme l'indique l'exemple suivant.


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.


Un caractère Unicode peut être encodé à l'aide de plusieurs objets Char et des valeurs d'index consécutives peuvent donc ne pas correspondre à des caractères Unicode consécutifs. En particulier, une chaîne peut contenir des unités de plusieurs caractères de texte qui sont constituées par un caractère de base suivi d'un ou plusieurs caractères d'association ou par une paire de substitution. Pour utiliser des caractères Unicode à la place d'objets Char, utilisez les classes System.Globalization.StringInfo et TextElementEnumerator. L'exemple suivant illustre la différence entre un code qui fonctionne avec les objets Char et un code qui fonctionne avec les caractères Unicode. Il compare le nombre de caractères ou éléments de type texte dans chaque mot d'une phrase. La chaîne inclut deux séquences d'un caractère de base suivies par un caractère d'association.


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


Cet exemple fonctionne avec des éléments de type texte en utilisant la méthode StringInfo.GetTextElementEnumerator et de la classe TextElementEnumerator pour énumérer tous les éléments de texte dans une chaîne. Vous pouvez également récupérer un tableau qui contient l'index de début de chaque élément de texte en appelant la méthode StringInfo.ParseCombiningCharacters.

Pour plus d'informations sur l'utilisation des unités de texte plutôt que des valeurs d'Char, consultez la classe StringInfo.

Chaînes null et chaînes vides

Une chaîne qui a été déclarée mais à laquelle aucune valeur n'a été assignée est null. La tentative d'appel des méthodes sur cette chaîne lève un NullReferenceException. Une chaîne null est différente d'une chaîne vide, qui est une chaîne dont la valeur est "" ou String.Empty. Dans certains cas, le passage d'une chaîne Null ou vide comme argument dans un appel de méthode lève une exception. Par exemple, le passage d'une chaîne nulle à la méthode Int32.Parse lève un ArgumentNullException, et le passage d'une chaîne vide lève un FormatException. Dans d'autres cas, un argument de la méthode peut être une chaîne Null ou une chaîne vide. Par exemple, si vous fournissez une implémentation IFormattable pour une classe, vous avez besoin d'associer à la fois une chaîne nulle et une chaîne vide avec le spécificateur de format général ("G").

La classe String inclut les deux méthodes pratiques suivantes qui vous permettent de tester si une chaîne est null ou vide :

  • IsNullOrEmpty , qui indique si une chaîne est null ou égale à String.Empty. Cette méthode élimine le besoin d'utiliser le code comme suit :

    
    if (str == null || str.Equals(String.Empty))
    
    
    
  • IsNullOrWhiteSpace , qui indique si une chaîne est null, égale String.Empty ou se compose exclusivement d'espaces blancs. Cette méthode élimine le besoin d'utiliser le code comme suit :

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

L'exemple suivant utilise la méthode IsNullOrEmpty dans l'implémentation IFormattable.ToString d'une classe Temperature personnalisée. La méthode prend en charge les chaînes de format "G", "C", "F" et "K". Si une chaîne de format vide ou une chaîne de format dont la valeur est null est passée à la méthode, sa valeur est remplacée par la chaîne de format "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));
   }                                   
}


Immuabilité et la classe StringBuilder

Un objet String est dit immuable (en lecture seule) car sa valeur ne peut pas être modifiée une fois qu'il a été créé. Les méthodes qui semblent modifier un objet String retournent en fait un nouvel objet String contenant la modification.

Les chaînes sont immuables, les routines de manipulation de chaînes qui exécutent les ajouts ou les suppressions répétés à ce qui semble être une chaîne unique peuvent rechercher une altération des performances significative. Par exemple, le code suivant utilise un générateur de nombres aléatoires pour créer une chaîne contenant 1000 caractères dans la plage 0x0001 à 0x052F. Bien que le code semble utiliser la concaténation de chaînes pour ajouter un nouveau caractère à la chaîne existante nommée str, il crée réellement un objet String pour chaque opération de concaténation.


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


Vous pouvez utiliser la classe StringBuilder au lieu de la classe String pour les opérations qui apportent plusieurs modifications à la valeur d'une chaîne. Contrairement aux instances de la classe String, les objets StringBuilder sont mutables ; lorsque vous concaténez, ajoutez ou supprimez des sous-chaînes d'une chaîne, les opérations sont exécutées sur une chaîne unique. Lorsque vous avez terminé de modifier la valeur d'un objet StringBuilder, vous pouvez appeler sa méthode StringBuilder.ToString pour le convertir en chaîne. L'exemple suivant remplace le String utilisé dans l'exemple précédent pour concaténer 1000 caractères aléatoires dans la plage comprise entre 0x0001 et 0x052F avec un objet 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();
   }
}


Nombre ordinal les des opérations dépendantes de la culture

Les membres de la classe String exécutent des opérations ordinales ou dépendantes de la culture (linguistique) sur un objet String. Une opération ordinale s'applique à la valeur numérique de chaque objet Char. Une opération dépendante de la culture s'applique à la valeur de l'objet String, et tient compte des règles spécifiques à la culture se rapportant à la casse, au tri, à la mise en forme et à l'analyse. Les opérations dépendantes de la culture sont exécutées dans le contexte d'une culture déclarée de manière explicite ou de la culture en cours implicite. Les deux types d'opérations peuvent produire des résultats très différents lorsqu'ils sont exécutés sur la même chaîne.

Note de sécuritéNote de sécurité

Si votre application prend une décision de sécurité à propos d'un identificateur symbolique tel qu'un nom de fichier ou canal nommé, ou de données rendues persistantes telles que les données textuelles dans un fichier XML, l'opération doit utiliser une comparaison ordinale plutôt qu'une comparaison dépendante de la culture. En effet, une comparaison dépendante de la culture peut produire des résultats différents selon la culture concernée, tandis qu'une comparaison ordinale dépend uniquement de la valeur binaire des caractères comparés.

Remarque importanteImportant

La plupart des méthodes qui exécutent des opérations de chaîne incluent une surcharge qui a un paramètre de type StringComparison, qui permet de spécifier si la méthode exécute une opération ordinale ou dépendante de la culture. En général, vous devez appeler cette surcharge afin que l'objectif de l'appel de la méthode soit clair. Pour obtenir les meilleures pratiques et des instructions sur les opérations ordinales et dépendantes de la culture réalisées sur les chaînes, consultez Meilleures pratiques pour l'utilisation de chaînes dans le .NET Framework.

Les opérations pour effectuer, analyse et mise en forme, comparaison et Sort, et tests d'égalité peuvent être ordinales ou dépendantes de la culture. Les sections suivantes traitent de chaque catégorie d'opération.

s1wwdcbf.collapse_all(fr-fr,VS.110).gifCasse

Les règles de casse déterminent comment modifier la mise en majuscules d'un caractère Unicode, par exemple comment convertir les minuscules en majuscules. Souvent, une opération de casse est exécutée avant une comparaison de chaînes. Par exemple, une chaîne peut être convertie en majuscule pour qu'elle puisse être comparée avec une autre chaîne majuscule. Vous pouvez convertir les caractères dans une chaîne en minuscules en appelant la méthode ToLower ou ToLowerInvariant, et vous pouvez les convertir en majuscules en appelant la méthode ToUpper ou ToUpperInvariant. De plus, vous pouvez utiliser la méthode TextInfo.ToTitleCase pour convertir une chaîne avec l'initiale en majuscule.

Les opérations de choix de la casse peuvent dépendre des règles de la culture actuelle, d'une culture spécifiée ou de la culture indifférente. Les mappages de cas peuvent varier selon la culture utilisée, le résultat des opérations de casse peut varier selon la culture. Les différences réelles dans la casse sont de trois types :

  • Différences dans le mappage de casse de la LETTRE MAJUSCULE LATINE I (U+0049), la MINUSCULE LATINE I (U+0069), de la LETTRE MAJUSCULE LATINE i WITH LE POINT CI-DESSUS (U+0130), et LATINE MINUSCULE i DOTLESS (U+0131). Dans le tr-TR (turc (Turquie)) et les cultures d'az-Latn-AZ (Azerbaïdjan, latin), et dans le tr, l'az, et les cultures neutres d'az-Latn, l'équivalent en minuscule de la LETTRE MAJUSCULE LATINE i est la MINUSCULE LATINE i DOTLESS, et l'équivalent de majuscule de la MINUSCULE LATINE i est la LETTRE MAJUSCULE LATINE i WITH LE POINT CI-DESSUS. Dans toutes les autres cultures, y compris la culture indifférente, la MINUSCULE LATINE i et la LETTRE MAJUSCULE LATINE i sont des équivalents minuscules et majuscules.

    L'exemple suivant montre comment une comparaison de chaînes conçue pour empêcher l'accès au système de fichiers peut échouer si elle repose sur une comparaison dépendante de la culture de casse. (Les conventions de casse de la culture dite indifférente doivent avoir été utilisées.)

    
    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
    
    
    
  • Différences au cas où mappages entre la culture indifférente et toutes les autres cultures. Dans ces cas, l'utilisation des règles de casse de la culture dite indifférente de modifier un caractère en majuscules ou en minuscules retourne le même caractère. Pour toutes les autres cultures, il retourne un caractère différent. Certains caractères affectés sont répertoriés dans le tableau suivant.

    Caractère

    Si changé à

    Returns (Retours)

    Appuyez sur MICRON (U+00B5)

    Majuscules

    VERR GRECQUE MU (U+-39C)

    LATIN CAPITAL LETTER i WITH LE POINT AU-DESSUS DE (U+0130)

    Minuscules

    MINUSCULE LATINE I (U+0069)

    MINUSCULE LATINE i DOTLESS (U+0131)

    Majuscules

    LATIN CAPITAL LETTER I (U+0049)

    MINUSCULE LATINE LONG S (U+017F)

    Majuscules

    LATIN CAPITAL LETTER S (U+0053)

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

    Minuscules

    MINUSCULE LATINE DZ WITH CARON (U+01C6)

    MIXANT YPOGEGRAMMENI GREC (U+0345)

    Majuscules

    VERR GRECQUE IOTA (U+0399)

  • Différences au cas où les mappages de la casse mixte à deux lettres s'accouplerait dans la chaîne de caractères ASCII. Dans la plupart des cultures, une paire à deux lettres à casse mixte est égale en majuscules à deux lettres équivalente ou aux paires casse. Elle ne convient pas pour deux paires de lettres suivantes dans les cultures suivantes, car dans chaque cas elles sont comparées à un digramme :

    • « lJ » et « nJ » dans la hr-HR (Croate (Croatie)) culture.

    • « Ch » en cs-CZ (tchèque (République tchèque)) et la sk-SK (slovaque (la Slovaquie)) cultures.

    • « aa » da-DK (Danois (le Danemark)) culture.

    • « .cs », « DZ », « dZS », « nY », « SZ », « tY », et « zS » dans le hu-HU (Hongrois (la Hongrie)) culture.

    • « Ch » et « lL » dans l'es-ES_tradnl (Espagnol (Espagne, tri traditionnel)) culture.

    • « Ch », « gI », « KH », « n » NH », « pH », « qU, « th », et « tr » dans la vi-VN (vietnamienne (le Viêt - Nam)) culture.

    Toutefois, il est rare de rencontrer une situation dans laquelle une comparaison dépendante de la culture de ces paires crée des problèmes, car ces paires sont rares dans les chaînes ou des identificateurs fixes.

L'exemple suivant illustre certaines différences dans les règles de casse entre les cultures lors de la conversion de chaînes en majuscule.


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(fr-fr,VS.110).gifAnalyse et mise en forme

La mise en forme et l'analyse sont des opérations inverses. Les règles de mise en forme déterminent comment convertir une valeur, telle qu'une date et une heure ou un nombre, en sa représentation sous forme de chaîne, tandis que les règles d'analyse déterminent comment convertir une représentation sous forme de chaîne en une valeur telle qu'une date et une heure. Les règles de mise en forme et d'analyse sont dépendantes des conventions culturelles. L'exemple suivant illustre l'ambiguïté qui peut survenir lors de l'interprétation des chaînes de dates spécifiques à la culture. Sans connaître les conventions de la culture utilisée pour produire des chaînes de date, il n'est pas possible de savoir si 03/01/2011, 3/1/2011 et 01/03/2011 représentent le 3 janvier 2011 ou le 1er mars 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


Pareillement, comme l'exemple suivant le montre, une chaîne unique peut produire des dates différentes en fonction de la culture dont les conventions sont utilisées dans l'opération d'analyse.


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(fr-fr,VS.110).gifComparaison de chaînes et Sort

Les règles de tri déterminent l'ordre alphabétique des caractères Unicode et la manière dont deux chaînes sont comparées. Par exemple, la méthode String.Compare(String, String, StringComparison) compare deux chaînes à l'aide du paramètre StringComparison. Si la valeur de paramètre est StringComparison.CurrentCulture, la méthode effectue une comparaison linguistique qui utilise les conventions de la culture actuelle ; si la valeur du paramètre est StringComparison.Ordinal, la méthode effectue une comparaison ordinale. Par conséquent, comme illustré dans l'exemple suivant, si la culture actuelle est Anglais - États-Unis, le premier appel à la méthode String.Compare(String, String, StringComparison) (à l'aide de la comparaison dépendante de la culture) considère « a » inférieur à « A », mais le deuxième appel à la même méthode (à l'aide de la comparaison ordinale) considère « a » supérieur à « 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


Le .NET Framework prend en charge les règles de tri des mots, des chaînes, ainsi que les règles de tri ordinal :

  • Un tri des mots effectue une comparaison, dépendante de la culture, des chaînes dans lesquelles une pondération différente peut être assignée à certains caractères Unicode non alphanumériques. Par exemple, une très petite pondération peut être assignée au tiret (-) afin que les mots "coop" et "co-op" se suivent dans une liste triée. Pour obtenir la liste des méthodes String qui comparent deux chaînes à l'aide de règles applicables au tri des mots, consultez la section Opérations de chaîne par catégorie.

  • Tri par chaîne qui effectue également une comparaison dépendante de la culture. Il est similaire au tri par mot, à ceci près qu'il n'y a aucun cas particulier et que tous les symboles non alphanumériques sont répertoriés avant tous les caractères Unicode alphanumériques. Deux chaînes peuvent être comparées à l'aide de règles de tri des chaînes en appelant les surcharges de méthode CompareInfo.Compare qui ont un paramètre options qui fournit une valeur de CompareOptions.StringSort. Notez qu'il s'agit de la seule méthode que le .NET Framework fournit pour comparer deux chaînes à l'aide de règles de tri des chaînes.

  • Le tri ordinal compare des chaînes sur la valeur numérique de chaque objet Char de la chaîne. Une comparaison ordinale respecte automatiquement la casse, car les versions minuscules et majuscules d'un caractère ont des points de code différents. Toutefois, si la casse n'est pas importante, vous pouvez spécifier une comparaison ordinale qui ignore la casse. Cela équivaut à convertir la chaîne en majuscules à l'aide de la culture indifférente et à effectuer ensuite une comparaison ordinale du résultat. Pour obtenir la liste des méthodes String qui comparent deux chaînes à l'ordinal trier des règles, consultez la section Opérations de chaîne par catégorie.

Une comparaison dépendante de la culture est une comparaison qui utilise explicitement ou implicitement un objet CultureInfo, y compris la culture indifférente qui est spécifiée par la propriété CultureInfo.InvariantCulture. La culture implicite est la culture actuelle, spécifiée par les propriétés Thread.CurrentCulture et CultureInfo.CurrentCulture. Il existe variation considérable de l'ordre de tri des lettres (autrement dit, caractères pour lesquelles la propriété Char.IsLetter retourne true) dans toutes les cultures. Vous pouvez spécifier une comparaison dépendante de la culture qui utilise les conventions d'une culture spécifique en fournissant un objet CultureInfo à une méthode de comparaison de chaînes telles que l'Compare(String, String, CultureInfo, CompareOptions). Vous pouvez spécifier une comparaison dépendante de la culture qui utilise des conventions de la culture actuelle en fournissant StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCase, ou un membre de l'énumération à CompareOptions autre que CompareOptions.Ordinal ou CompareOptions.OrdinalIgnoreCase à une surcharge appropriée de la méthode Compare. Une comparaison dépendante de la culture est généralement appropriée pour le tri pendant qu'une comparaison ordinale n'est pas. Une comparaison ordinale est généralement appropriée pour déterminer si deux chaînes sont égales (autrement dit, pour déterminer l'identité) lorsqu'une comparaison dépendante de la culture n'est pas.

Utilisez les recommandations générales suivantes pour sélectionner une méthode appropriée de tri ou de comparaison de chaînes :

  • Si vous souhaitez que les chaînes doivent être classés selon la culture de l'utilisateur, vous devez les classer selon les conventions de la culture actuelle. Si la culture de l'utilisateur change, l'ordre de chaînes triées change également en conséquence. Par exemple, une application de thésaurus doit toujours trier des mots selon la culture de l'utilisateur.

  • Si vous souhaitez que les chaînes doivent être classés selon les conventions d'une culture spécifique, vous devez les classer en fournissant un objet CultureInfo qui représente cette culture à une méthode de comparaison. Par exemple, dans une application conçue pour enseigner à des étudiants un langage particulier, vous souhaitez que les chaînes doivent être classés selon les conventions d'une des cultures qui explique ce langage.

  • Si vous souhaitez l'ordre de chaînes de rester inchangé dans toutes les cultures, vous devez les classer selon les conventions de la culture indifférente ou utiliser une comparaison ordinale. Par exemple, vous utiliserez un tri ordinal pour organiser les noms des fichiers, des processus, les mutex, ou des canaux nommés.

  • Pour une comparaison qui comporte une décision de sécurité (si un nom d'utilisateur est valide), vous devez toujours effectuer un test ordinal d'égalité en appelant une surcharge de la méthode Equals.

RemarqueRemarque

Le tri dépendant de la culture et les règles de casse utilisées dans la comparaison de chaînes dépendent de la version du .NET Framework. Dans .NET Framework 4.5 qui s'exécutent sur le système d'exploitation d'Windows 8, le tri, la casse, la normalisation, et les informations de caractères Unicode se conforme à la norme Unicode 6,0. Sur d'autres systèmes d'exploitation, elle se conforme à la norme Unicode 5,0.

Pour plus d'informations sur les règles applicables au tri des mots, des chaînes et au tri ordinal, consultez la rubrique System.Globalization.CompareOptions. Pour obtenir des recommandations supplémentaires supérieure sur le moment où utiliser chaque règle, consultez Meilleures pratiques pour l'utilisation de chaînes dans le .NET Framework.

En règle générale, vous n'appelez pas directement les méthodes de comparaison de chaînes comme Compare pour déterminer l'ordre de tri des chaînes. Au lieu de cela, les méthodes de comparaison sont appelées par les méthodes de tri telles que Array.Sort ou List<T>.Sort. L'exemple suivant exécute quatre opérations de tri différentes (tri des mots à l'aide de la culture actuelle, tri des mots à l'aide de la culture indifférente, tri ordinal et tri des chaînes à l'aide de la culture indifférente) sans appeler de méthode de comparaison de chaînes explicitement. Notez que chaque type de tri produit un classement unique de chaînes dans son tableau.


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


Mise en gardeAttention

Si votre objectif premier dans la comparaison des chaînes est de déterminer si elles sont égales, vous devez appeler la méthode String.Equals. En général, vous devez utiliser Equals pour effectuer une comparaison ordinale. La méthode String.Compare vise principalement le tri des chaînes.

Les méthodes de recherche de chaînes, telles que String.StartsWith et String.IndexOf, peuvent également exécuter des comparaisons de chaînes dépendantes de la culture ou ordinales. L'exemple suivant illustre les différences entre des comparaisons ordinales et dépendantes de la culture à l'aide de la méthode IndexOf. Une recherche dépendante de la culture dans laquelle la culture actuelle est l'anglais (États-Unis) met en correspondance la sous-chaîne "oe" avec la ligature "œ". Étant donné qu'un tiret conditionnel (U+00AD) est un caractère de largeur nulle, la recherche traite le tiret conditionnel comme équivalent à Empty et recherche une correspondance au début de la chaîne. En revanche, une recherche ordinale ne trouve aucune correspondance dans chaque cas.


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(fr-fr,VS.110).gifTester l'égalité

Utilisez la méthode String.Compare pour déterminer la relation entre deux chaînes dans l'ordre de tri. En général, c'est une opération dépendante de la culture. En revanche, appelez la méthode String.Equals pour tester l'égalité. Étant donné que le test d'égalité compare habituellement l'entrée utilisateur avec une chaîne connue, telle qu'un nom d'utilisateur valide, un mot de passe ou un chemin d'accès de système de fichiers, il s'agit en général d'une opération ordinale.

Mise en gardeAttention

Il est possible de tester l'égalité en appelant la méthode String.Compare et en déterminant si la valeur de retour est nulle. Toutefois, cette pratique n'est pas recommandée. Pour déterminer si deux chaînes sont égales, vous devez appeler l'une des surcharges de la méthode String.Equals. La surcharge par défaut à appeler est la méthode Equals(String, StringComparison) de l'instance ou la méthode Equals(String, String, StringComparison) statique, parce que les deux méthodes incluent un paramètre System.StringComparison qui spécifie explicitement le type de comparaison.

L'exemple suivant illustre le danger lié à une comparaison dépendante de la culture pour tester l'égalité lorsqu'un ordinal doit être utilisé à la place. Dans ce cas, l'intention du code est d'interdire l'accès au système de fichiers à partir des URL qui commencent par "FILE://" ou "file://" en exécutant une comparaison ne respectant pas la casse du début d'une URL avec la chaîne "FILE://". Toutefois, si une comparaison dépendante de la culture est effectuée à l'aide de la culture turque (Turquie) sur une URL qui commence par "file://", la comparaison d'égalité échoue car la majuscule turque qui équivaut à la minuscule "i" est "İ" et non"I". Par conséquent, l'accès au système de fichiers est autorisé accidentellement. En revanche, si une comparaison ordinale est effectuée, la comparaison pour l'égalité réussit, et l'accès au système de fichiers est refusé.


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.


Normalisation

Certains caractères Unicode ont plusieurs représentations. Par exemple, chacun des points de code suivants peut représenter la lettre "ắ" :

  • U+1EAF

  • U+0103 U+0301

  • U+0061 U+0306 U+0301

La représentation multiple pour un même caractère complique la recherche, le tri, la mise en correspondance et les autres opérations de chaînes.

La norme Unicode définit un processus appelé normalisation, celui qui retourne une seule représentation binaire d'un caractère Unicode pour toutes ses représentations binaires équivalentes d'un caractère. La normalisation peut utiliser plusieurs algorithmes, appelés formulaires de normalisation, qui respectent différentes règles. Le .NET Framework prend en charge les formulaires de normalisation Unicode C, D, KC et KD. Lorsque les chaînes ont été normalisées avec le même formulaire de normalisation, elles peuvent être comparées à l'aide d'une comparaison ordinale.

Une comparaison ordinale est une comparaison binaire de la valeur scalaire Unicode des objets Char correspondants dans chaque chaîne. La classe String inclut plusieurs méthodes capables d'effectuer une comparaison ordinale, notamment :

Vous pouvez déterminer si une chaîne est normalisée dans le formulaire de normalisation C en appelant la méthode String.IsNormalized(), ou vous pouvez appeler la méthode String.IsNormalized(NormalizationForm) pour déterminer si une chaîne est normalisée dans un formulaire de normalisation spécifié. Vous pouvez également appeler la méthode String.Normalize() pour convertir une chaîne en formulaire de normalisation C, ou vous pouvez appeler la méthode String.Normalize(NormalizationForm) pour convertir une chaîne en formulaire de normalisation spécifié. Pour des informations pas - à - pas sur la normalisation et comparer des chaînes, consultez Normalize() et les méthodes Normalize(NormalizationForm).

L'exemple simple suivant montre la forme de chaîne. Il définit la lettre "ố" de trois façons différentes dans trois chaînes différentes, et utilise une comparaison ordinale pour l'égalité afin de déterminer si chaque chaîne diffère des deux autres chaînes. Elle convertit alors chaque chaîne dans des formats de normalisation pris en charge, et effectue de nouveau une comparaison ordinale de chaque chaîne dans un format de normalisation spécifié. Dans chaque cas, le deuxième test d'égalité indique que les chaînes sont égales.


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


Pour plus d'informations sur la normalisation et les formulaires de normalisation, consultez System.Text.NormalizationForm, ainsi qu' Annexe #15 de norme Unicode : Les formulaires de normalisation Unicode et Activation FAQ de normalisation dans le site Web d'unicode.org.

Opérations de chaîne par catégorie

La classe String fournit des membres pour la comparaison de chaînes, en testant l'égalité des chaînes, la recherche des caractères ou des sous-chaînes dans une chaîne, la modification d'une chaîne, la récupération des sous-chaînes d'une chaîne, la combinaison des chaînes, la mise en forme des valeurs, la copie d'une chaîne et la normalisation d'une chaîne.

s1wwdcbf.collapse_all(fr-fr,VS.110).gifComparaison de chaînes

Vous pouvez comparer les chaînes pour déterminer leur position relative dans l'ordre de tri à l'aide des méthodes String suivantes :

  • Compare retourne un entier qui indique la relation entre une chaîne et une deuxième chaîne dans l'ordre de tri.

  • CompareOrdinal retourne un entier qui indique la relation entre une chaîne et une deuxième chaîne selon une comparaison de leurs points de code.

  • CompareTo retourne un entier qui indique la relation entre l'instance de chaîne actuelle et une deuxième chaîne dans l'ordre de tri. La méthode CompareTo(String) fournit les implémentations IComparable<T> et IComparable pour la classe String.

s1wwdcbf.collapse_all(fr-fr,VS.110).gifChaînes de test d'égalité

Faites appel à la méthode Equals pour déterminer si deux chaînes sont équivalentes. L'instance Equals(String, String, StringComparison) et les surcharges Equals(String, StringComparison) statiques vous permettent de spécifier si la comparaison est dépendante de la culture ou ordinale, et si la casse est considérée ou ignorée. La plupart des tests d'égalité sont ordinaux, et les comparaisons d'égalité qui déterminent l'accès à une ressource système (tel qu'un objet du système de fichiers) doivent toujours être ordinales.

s1wwdcbf.collapse_all(fr-fr,VS.110).gifRecherche des caractères d'une chaîne

La classe String inclut deux types de méthodes de recherche :

  • Méthodes qui retournent une valeur Boolean pour indiquer si une sous-chaîne particulière est présente dans une instance de chaîne. Il s'agit notamment des méthodes Contains, EndsWith et StartsWith.

  • Méthodes qui indiquent la position de départ d'une sous-chaîne dans une instance de chaîne. Il s'agit notamment des méthodes IndexOf, IndexOfAny, LastIndexOf et LastIndexOfAny.

Mise en gardeAttention

Si vous souhaitez rechercher une chaîne pour un modèle particulier plutôt qu'une sous-chaîne spécifique, vous devez utiliser des expressions régulières. Pour plus d'informations, consultez Expressions régulières du .NET Framework.

s1wwdcbf.collapse_all(fr-fr,VS.110).gifModification d'une chaîne

La classe String inclut les méthodes suivantes qui semblent modifier la valeur d'une chaîne :

  • Insert insère une chaîne dans l'instance String actuelle.

  • PadLeft insère une ou plusieurs occurrences d'un caractère spécifié au début de la chaîne.

  • PadRight insère une ou plusieurs occurrences d'un caractère spécifié au début de la chaîne.

  • Remove supprime une sous-chaîne de l'instance String actuelle.

  • Replace remplace une sous-chaîne par une autre sous-chaîne dans l'instance String actuelle.

  • ToLower et ToLowerInvariant convertissent tous les caractères d'une chaîne en minuscules.

  • ToUpper et ToUpperInvariant convertissent tous les caractères d'une chaîne en majuscules.

  • Trim supprime toutes les occurrences d'un caractère du début à la fin d'une chaîne.

  • TrimEnd supprime toutes les occurrences d'un caractère de la fin d'une chaîne.

  • TrimStart supprime toutes les occurrences d'un caractère du début d'une chaîne.

Remarque importanteImportant

Toutes les méthodes de modification de chaîne retournent un nouvel objet String. Ils ne modifient pas la valeur de l'instance actuelle.

s1wwdcbf.collapse_all(fr-fr,VS.110).gifExtraction de sous-chaînes d'une chaîne

La méthode String.Split sépare une chaîne unique dans plusieurs chaînes. Les surcharges de la méthode permettent de spécifier plusieurs délimiteurs, pour déterminer le nombre maximum de sous-chaînes que la méthode extrait, et pour déterminer si les chaînes vides (qui se produisent lorsque les délimiteurs sont adjacents) sont incluses dans les chaînes retournées.

s1wwdcbf.collapse_all(fr-fr,VS.110).gifCombinaison des chaînes

Les méthodes String suivantes peuvent être utilisées pour la concaténation de chaînes :

  • Concat combine une ou plusieurs sous-chaînes dans une chaîne unique.

  • Join concatène une ou plusieurs sous-chaînes dans un élément unique et ajoute un séparateur entre chaque sous-chaîne.

s1wwdcbf.collapse_all(fr-fr,VS.110).gifValeurs de mise en forme

La méthode String.Format utilise la fonctionnalité de mise en forme composite pour remplacer un ou plusieurs espaces réservés dans une chaîne par la représentation sous forme de chaîne de certains objets ou valeurs. La méthode Format est souvent utilisée pour effectuer les opérations suivantes :

  • Pour incorporer la représentation sous forme de chaîne d'une valeur numérique dans une chaîne.

  • Pour incorporer la représentation sous forme de chaîne d'une valeur de date et heure dans une chaîne.

  • Pour incorporer la représentation sous forme de chaîne d'une valeur d'énumération dans une chaîne.

  • Pour incorporer la représentation sous forme de chaîne d'un objet quelconque qui prend en charge l'interface IFormattable dans une chaîne.

  • Pour justifier à droite ou à gauche une sous-chaîne dans un champ d'une plus grande chaîne.

Pour plus d'informations sur les opérations et des exemples de mise en forme, consultez le résumé de la surcharge d'Format.

s1wwdcbf.collapse_all(fr-fr,VS.110).gifCopie d'une chaîne

Vous pouvez appeler les méthodes String suivantes pour effectuer la copie d'une chaîne :

  • Clone Retourne une référence à un objet String existant.

  • Copy crée une copie d'une chaîne existante.

  • CopyTo copie une partie d'une chaîne dans un tableau de caractères.

s1wwdcbf.collapse_all(fr-fr,VS.110).gifNormalisation d'une chaîne

En Unicode, un caractère unique peut avoir plusieurs points de code. La normalisation convertit ces caractères équivalents en représentation binaire identique. La méthode String.Normalize exécute la normalisation, et la méthode String.IsNormalized détermine si une chaîne est normalisée.

.NET Framework

Pris en charge dans : 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Bibliothèque de classes portable

Pris en charge dans : Bibliothèque de classes portable

.NET pour les applications du Windows Store

Pris en charge dans : Windows 8

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (rôle principal du serveur non pris en charge), Windows Server 2008 R2 (rôle principal du serveur pris en charge avec SP1 ou version ultérieure ; Itanium non pris en charge)

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

Ce type est thread-safe.

Cela vous a-t-il été utile ?
(1500 caractères restants)
Merci pour vos suggestions.

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft. Tous droits réservés.