Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

String classe

 

Date de publication : novembre 2016

Représente le texte en tant que séquence d’unités de code UTF-16.

Pour parcourir le code source de .NET Framework pour ce type, consultez la Reference Source.

Espace de noms:   System
Assembly:  mscorlib (dans mscorlib.dll)


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

NomDescription
System_CAPS_pubmethodString(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.

System_CAPS_pubmethodString(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.

System_CAPS_pubmethodString(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.

System_CAPS_pubmethodString(Char[])

Initialise une nouvelle instance de la classe String à la valeur indiquée par un tableau de caractères Unicode.

System_CAPS_pubmethodString(Char[], Int32, Int32)

Initialise une nouvelle instance de la classe String à la valeur indiquée par un tableau de caractères Unicode, une position de départ pour le caractère dans ce tableau et une longueur.

System_CAPS_pubmethodString(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.

System_CAPS_pubmethodString(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.

System_CAPS_pubmethodString(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.

NomDescription
System_CAPS_pubpropertyChars[Int32]

Obtient l'objet Char à une position de caractère spécifiée dans l'objet String actuel.

System_CAPS_pubpropertyLength

Obtient le nombre de caractères de l'objet String actuel.

NomDescription
System_CAPS_pubmethodClone()

Retourne une référence à cette instance de String.

System_CAPS_pubmethodSystem_CAPS_staticCompare(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.

System_CAPS_pubmethodSystem_CAPS_staticCompare(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.

System_CAPS_pubmethodSystem_CAPS_staticCompare(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.

System_CAPS_pubmethodSystem_CAPS_staticCompare(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.

System_CAPS_pubmethodSystem_CAPS_staticCompare(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.

System_CAPS_pubmethodSystem_CAPS_staticCompare(String, String)

Compare deux objets String spécifiés et retourne un entier qui indique leur position relative dans l'ordre de tri.

System_CAPS_pubmethodSystem_CAPS_staticCompare(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.

System_CAPS_pubmethodSystem_CAPS_staticCompare(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.

System_CAPS_pubmethodSystem_CAPS_staticCompare(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.

System_CAPS_pubmethodSystem_CAPS_staticCompare(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.

System_CAPS_pubmethodSystem_CAPS_staticCompareOrdinal(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.

System_CAPS_pubmethodSystem_CAPS_staticCompareOrdinal(String, String)

Compare deux objets String spécifiés en évaluant les valeurs numériques des objets Char correspondants dans chaque chaîne.

System_CAPS_pubmethodCompareTo(Object)

Compare cette instance avec un Object spécifié et indique si cette instance précède, suit ou apparaît à la même position dans l'ordre de tri que le Object spécifié.

System_CAPS_pubmethodCompareTo(String)

Compare cette instance avec un objet String spécifié et indique si cette instance précède, suit ou apparaît à la même position dans l'ordre de tri que la chaîne spécifiée.

System_CAPS_pubmethodSystem_CAPS_staticConcat(IEnumerable<String>)

Concatène les membres d'une collection IEnumerable<T> construite de type String.

System_CAPS_pubmethodSystem_CAPS_staticConcat(Object)

Crée la représentation sous forme de chaîne d'un objet spécifié.

System_CAPS_pubmethodSystem_CAPS_staticConcat(Object, Object)

Concatène les représentations sous forme de chaîne de deux objets spécifiés.

System_CAPS_pubmethodSystem_CAPS_staticConcat(Object, Object, Object)

Concatène les représentations sous forme de chaîne de trois objets spécifiés.

System_CAPS_pubmethodSystem_CAPS_staticConcat(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 facultative de paramètres de longueur variable.

System_CAPS_pubmethodSystem_CAPS_staticConcat(Object[])

Concatène les représentations sous forme de chaîne des éléments dans un tableau Object spécifié.

System_CAPS_pubmethodSystem_CAPS_staticConcat(String, String)

Concatène deux instances spécifiées de String.

System_CAPS_pubmethodSystem_CAPS_staticConcat(String, String, String)

Concatène trois instances spécifiées de String.

System_CAPS_pubmethodSystem_CAPS_staticConcat(String, String, String, String)

Concatène quatre instances spécifiées de String.

System_CAPS_pubmethodSystem_CAPS_staticConcat(String[])

Concatène les éléments d'un tableau String spécifié.

System_CAPS_pubmethodSystem_CAPS_staticConcat<T>(IEnumerable<T>)

Concatène les membres d'une implémentation IEnumerable<T>.

System_CAPS_pubmethodContains(String)

Retourne une valeur qui indique si la sous-chaîne spécifiée apparaît dans cette chaîne.

System_CAPS_pubmethodSystem_CAPS_staticCopy(String)

Crée une instance de String ayant la même valeur qu'un String spécifié.

System_CAPS_pubmethodCopyTo(Int32, Char[], Int32, Int32)

Copie un nombre spécifié de caractères à partir d'une position spécifiée dans cette instance vers une position spécifiée dans un tableau de caractères Unicode.

System_CAPS_pubmethodEndsWith(String)

Détermine si la fin de cette instance de chaîne correspond à la chaîne spécifiée.

System_CAPS_pubmethodEndsWith(String, Boolean, CultureInfo)

Détermine si la fin de cette instance de chaîne correspond à la chaîne spécifiée quand elle est comparée à l'aide de la culture spécifiée.

System_CAPS_pubmethodEndsWith(String, StringComparison)

Détermine si la fin de cette instance de chaîne correspond à la chaîne spécifiée quand elle est comparée à l'aide de l'option spécifiée.

System_CAPS_pubmethodEquals(Object)

Détermine si cette instance et un objet spécifié, qui doit aussi être un objet String, ont la même valeur.(Remplace Object.Equals(Object).)

System_CAPS_pubmethodEquals(String)

Détermine si cette instance et un autre objet String spécifié ont la même valeur.

System_CAPS_pubmethodSystem_CAPS_staticEquals(String, String)

Détermine si deux objets String spécifiés ont la même valeur.

System_CAPS_pubmethodSystem_CAPS_staticEquals(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.

System_CAPS_pubmethodEquals(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.

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object)

Remplace le ou les éléments de mise en forme d'une chaîne spécifiée par la représentation sous forme de chaîne de l'objet correspondant. Un paramètre fournit des informations de mise en forme propres à la culture.

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, 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. Un paramètre fournit des informations de mise en forme propres à la culture.

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, 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. Un paramètre fournit des informations de mise en forme propres à la culture.

System_CAPS_pubmethodSystem_CAPS_staticFormat(IFormatProvider, String, Object[])

Remplace les éléments de mise en forme d'une chaîne spécifiée par les représentations sous forme de chaîne des objets correspondants dans un tableau spécifié. Un paramètre fournit des informations de mise en forme propres à la culture.

System_CAPS_pubmethodSystem_CAPS_staticFormat(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é.

System_CAPS_pubmethodSystem_CAPS_staticFormat(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.

System_CAPS_pubmethodSystem_CAPS_staticFormat(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.

System_CAPS_pubmethodSystem_CAPS_staticFormat(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é.

System_CAPS_pubmethodGetEnumerator()

Récupère un objet qui peut itérer au sein des caractères individuels de cette chaîne.

System_CAPS_pubmethodGetHashCode()

Retourne le code de hachage pour cette chaîne.(Remplace Object.GetHashCode().)

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_pubmethodGetTypeCode()

Retourne TypeCode pour la classe String.

System_CAPS_pubmethodIndexOf(Char)

Signale l'index de base zéro de la première occurrence du caractère Unicode spécifié dans cette chaîne.

System_CAPS_pubmethodIndexOf(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 commence à une position de caractère spécifiée.

System_CAPS_pubmethodIndexOf(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 spécifié de positions de caractère.

System_CAPS_pubmethodIndexOf(String)

Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans cette instance.

System_CAPS_pubmethodIndexOf(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 commence à une position de caractère spécifiée.

System_CAPS_pubmethodIndexOf(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 spécifié de positions de caractère.

System_CAPS_pubmethodIndexOf(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 actuel. Les paramètres spécifient le point de départ de la recherche dans la chaîne actuelle, le nombre de caractères de la chaîne dans laquelle effectuer la recherche et le type de recherche à utiliser pour la chaîne spécifiée.

System_CAPS_pubmethodIndexOf(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 actuel. Les paramètres spécifient la position de départ de la recherche dans la chaîne actuelle et le type de recherche à utiliser pour la chaîne spécifiée.

System_CAPS_pubmethodIndexOf(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 actuel. Un paramètre spécifie le type de recherche à utiliser pour la chaîne spécifiée.

System_CAPS_pubmethodIndexOfAny(Char[])

Signale l'index de base zéro de la première occurrence dans cette instance de tout caractère d'un tableau de caractères Unicode spécifié.

System_CAPS_pubmethodIndexOfAny(Char[], Int32)

Signale l'index de base zéro de la première occurrence dans cette instance de tout caractère d'un tableau de caractères Unicode spécifié. La recherche commence à une position de caractère spécifiée.

System_CAPS_pubmethodIndexOfAny(Char[], Int32, Int32)

Signale l'index de base zéro de la première occurrence dans cette instance de tout caractère d'un tableau de caractères Unicode spécifié. La recherche commence à une position de caractère spécifiée et examine un nombre spécifié de positions de caractère.

System_CAPS_pubmethodInsert(Int32, String)

Retourne 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.

System_CAPS_pubmethodSystem_CAPS_staticIntern(String)

Récupère la référence du système au String spécifié.

System_CAPS_pubmethodSystem_CAPS_staticIsInterned(String)

Récupère une référence à un String spécifié.

System_CAPS_pubmethodIsNormalized()

Indique si cette chaîne se trouve dans un formulaire de normalisation C Unicode.

System_CAPS_pubmethodIsNormalized(NormalizationForm)

Indique si cette chaîne figure dans le formulaire de normalisation Unicode spécifié.

System_CAPS_pubmethodSystem_CAPS_staticIsNullOrEmpty(String)

Indique si la chaîne spécifiée est null ou une chaîne Empty.

System_CAPS_pubmethodSystem_CAPS_staticIsNullOrWhiteSpace(String)

Indique si une chaîne spécifiée est null, vide ou se compose uniquement d'espaces blancs.

System_CAPS_pubmethodSystem_CAPS_staticJoin(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.

System_CAPS_pubmethodSystem_CAPS_staticJoin(String, Object[])

Concatène les éléments d'un tableau d'objets, en utilisant le séparateur spécifié entre chaque élément.

System_CAPS_pubmethodSystem_CAPS_staticJoin(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.

System_CAPS_pubmethodSystem_CAPS_staticJoin(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.

System_CAPS_pubmethodSystem_CAPS_staticJoin<T>(String, IEnumerable<T>)

Concatène les membres d'une collection, en utilisant le séparateur spécifié entre chaque membre.

System_CAPS_pubmethodLastIndexOf(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.

System_CAPS_pubmethodLastIndexOf(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 se poursuit vers le début de la chaîne.

System_CAPS_pubmethodLastIndexOf(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.

System_CAPS_pubmethodLastIndexOf(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.

System_CAPS_pubmethodLastIndexOf(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 se poursuit vers le début de la chaîne.

System_CAPS_pubmethodLastIndexOf(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.

System_CAPS_pubmethodLastIndexOf(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. Un paramètre spécifie le type de comparaison à effectuer pendant la recherche de la chaîne spécifiée.

System_CAPS_pubmethodLastIndexOf(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 actuel. La recherche commence à une position de caractère spécifiée et se poursuit vers le début de la chaîne. Un paramètre spécifie le type de comparaison à effectuer pendant la recherche de la chaîne spécifiée.

System_CAPS_pubmethodLastIndexOf(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 actuel. Un paramètre spécifie le type de recherche à utiliser pour la chaîne spécifiée.

System_CAPS_pubmethodLastIndexOfAny(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.

System_CAPS_pubmethodLastIndexOfAny(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 se poursuit vers le début de la chaîne.

System_CAPS_pubmethodLastIndexOfAny(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.

System_CAPS_pubmethodNormalize()

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.

System_CAPS_pubmethodNormalize(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é.

System_CAPS_pubmethodPadLeft(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.

System_CAPS_pubmethodPadLeft(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.

System_CAPS_pubmethodPadRight(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.

System_CAPS_pubmethodPadRight(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.

System_CAPS_pubmethodRemove(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.

System_CAPS_pubmethodRemove(Int32, Int32)

Retourne une nouvelle chaîne dans laquelle un nombre spécifié de caractères a été supprimé dans l'instance actuelle à partir d'une position spécifiée.

System_CAPS_pubmethodReplace(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é.

System_CAPS_pubmethodReplace(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.

System_CAPS_pubmethodSplit(Char[])

Divise une chaîne en sous-chaînes en fonction des caractères contenus dans un tableau.

System_CAPS_pubmethodSplit(Char[], Int32)

Fractionne une chaîne en un nombre maximal de sous-chaînes en fonction des caractères contenus dans un tableau. Vous pouvez aussi spécifier le nombre maximal de sous-chaînes à retourner.

System_CAPS_pubmethodSplit(Char[], Int32, StringSplitOptions)

Fractionne une chaîne en un nombre maximal de sous-chaînes en fonction des caractères contenus dans un tableau.

System_CAPS_pubmethodSplit(Char[], StringSplitOptions)

Fractionne une chaîne en sous-chaînes en fonction des caractères contenus dans un tableau. Vous pouvez préciser si les sous-chaînes incluent les éléments d'un tableau vide.

System_CAPS_pubmethodSplit(String[], Int32, StringSplitOptions)

Fractionne une chaîne en un nombre maximal de sous-chaînes en fonction des chaînes contenues dans un tableau. Vous pouvez préciser si les sous-chaînes incluent les éléments d'un tableau vide.

System_CAPS_pubmethodSplit(String[], StringSplitOptions)

Fractionne une chaîne en sous-chaînes en fonction des chaînes contenues dans un tableau. Vous pouvez préciser si les sous-chaînes incluent les éléments d'un tableau vide.

System_CAPS_pubmethodStartsWith(String)

Détermine si le début de cette instance de chaîne correspond à la chaîne spécifiée.

System_CAPS_pubmethodStartsWith(String, Boolean, CultureInfo)

Détermine si le début de cette instance de chaîne correspond à la chaîne spécifiée quand elle est comparée à l'aide de la culture spécifiée.

System_CAPS_pubmethodStartsWith(String, StringComparison)

Détermine si le début de cette instance de chaîne correspond à la chaîne spécifiée quand elle est comparée à l'aide de l'option spécifiée.

System_CAPS_pubmethodSubstring(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.

System_CAPS_pubmethodSubstring(Int32, 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 sa longueur est définie.

System_CAPS_pubmethodToCharArray()

Copie les caractères de cette instance vers un tableau de caractères Unicode.

System_CAPS_pubmethodToCharArray(Int32, Int32)

Copie les caractères d'une sous-chaîne spécifiée de cette instance vers un tableau de caractères Unicode.

System_CAPS_pubmethodToLower()

Retourne une copie de cette chaîne convertie en minuscules.

System_CAPS_pubmethodToLower(CultureInfo)

Retourne une copie de cette chaîne en minuscules, à l'aide des règles de casse de la culture spécifiée.

System_CAPS_pubmethodToLowerInvariant()

Retourne une copie de cet objet String converti en minuscules à l'aide des règles de casse de la culture indifférente.

System_CAPS_pubmethodToString()

Retourne cette instance de String ; aucune conversion n'est effectivement effectuée.(Remplace Object.ToString().)

System_CAPS_pubmethodToString(IFormatProvider)

Retourne cette instance de String ; aucune conversion n'est effectivement effectuée.

System_CAPS_pubmethodToUpper()

Retourne une copie de cette chaîne convertie en majuscules.

System_CAPS_pubmethodToUpper(CultureInfo)

Retourne une copie de cette chaîne convertie en majuscules à l'aide des règles de casse de la culture spécifiée.

System_CAPS_pubmethodToUpperInvariant()

Retourne une copie de cet objet String converti en majuscules à l'aide des règles de casse de la culture indifférente.

System_CAPS_pubmethodTrim()

Supprime tous les espaces blancs de début ou de fin de chaîne de l'objet String actuel.

System_CAPS_pubmethodTrim(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.

System_CAPS_pubmethodTrimEnd(Char[])

Supprime, de l'objet String actuel, toutes les occurrences situées à la fin d'un jeu de caractères spécifiés dans un tableau.

System_CAPS_pubmethodTrimStart(Char[])

Supprime, 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.

NomDescription
System_CAPS_pubfieldSystem_CAPS_staticEmpty

Représente la chaîne vide. Ce champ est en lecture seule.

NomDescription
System_CAPS_puboperatorSystem_CAPS_staticEquality(String, String)

Détermine si deux chaînes spécifiées ont la même valeur.

System_CAPS_puboperatorSystem_CAPS_staticInequality(String, String)

Détermine si deux chaînes spécifiées ont des valeurs différentes.

NomDescription
System_CAPS_pubinterfaceSystem_CAPS_privmethodIEnumerable<Char>.GetEnumerator()

Retourne un énumérateur qui itère au sein de l'objet String actuel.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIEnumerable.GetEnumerator()

Retourne un énumérateur qui itère au sein de l'objet String actuel.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToBoolean(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez ToBoolean.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToByte(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez ToByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToChar(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez ToChar.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDateTime(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez ToDateTime.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDecimal(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez ToDecimal.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToDouble(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez ToDouble.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt16(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez ToInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt32(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez ToInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToInt64(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez ToInt64.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSByte(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez ToSByte.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToSingle(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez ToSingle.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToType(Type, IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez ToType.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt16(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez ToUInt16.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt32(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez ToUInt32.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIConvertible.ToUInt64(IFormatProvider)

Cette API prend en charge l’infrastructure de produit et n’est pas destinée à être utilisée directement depuis votre code. Pour obtenir une description de ce membre, consultez ToUInt64.

NomDescription
System_CAPS_pubmethodAggregate<Char>(Func<Char, Char, Char>)

Surchargé. Applique une fonction d’accumulation sur une séquence.(Défini par Enumerable.)

System_CAPS_pubmethodAggregate<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.)

System_CAPS_pubmethodAggregate<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.)

System_CAPS_pubmethodAll<Char>(Func<Char, Boolean>)

Détermine si tous les éléments d’une séquence remplissent une condition.(Défini par Enumerable.)

System_CAPS_pubmethodAny<Char>()

Surchargé. Détermine si une séquence contient des éléments.(Défini par Enumerable.)

System_CAPS_pubmethodAny<Char>(Func<Char, Boolean>)

Surchargé. Détermine si les éléments d’une séquence satisfont à une condition.(Défini par Enumerable.)

System_CAPS_pubmethodAsEnumerable<Char>()

Retourne l’entrée typée comme IEnumerable<T>.(Défini par Enumerable.)

System_CAPS_pubmethodAsParallel()

Surchargé. Active la parallélisation d'une requête.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAsParallel<Char>()

Surchargé. Active la parallélisation d'une requête.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAsQueryable()

Surchargé. Convertit un IEnumerable à un IQueryable.(Défini par Queryable.)

System_CAPS_pubmethodAsQueryable<Char>()

Surchargé. Convertit un type générique IEnumerable<T> générique IQueryable<T>.(Défini par Queryable.)

System_CAPS_pubmethodAverage<Char>(Func<Char, Decimal>)

Surchargé. Calcule la moyenne d’une séquence de Decimal valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.(Défini par Enumerable.)

System_CAPS_pubmethodAverage<Char>(Func<Char, Double>)

Surchargé. Calcule la moyenne d’une séquence de Double valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.(Défini par Enumerable.)

System_CAPS_pubmethodAverage<Char>(Func<Char, Int32>)

Surchargé. Calcule la moyenne d’une séquence de Int32 valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.(Défini par Enumerable.)

System_CAPS_pubmethodAverage<Char>(Func<Char, Int64>)

Surchargé. Calcule la moyenne d’une séquence de Int64 valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.(Défini par Enumerable.)

System_CAPS_pubmethodAverage<Char>(Func<Char, Nullable<Decimal>>)

Surchargé. Calcule la moyenne d’une séquence de type nullable Decimal valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.(Défini par Enumerable.)

System_CAPS_pubmethodAverage<Char>(Func<Char, Nullable<Double>>)

Surchargé. Calcule la moyenne d’une séquence de type nullable Double valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.(Défini par Enumerable.)

System_CAPS_pubmethodAverage<Char>(Func<Char, Nullable<Int32>>)

Surchargé. Calcule la moyenne d’une séquence de type nullable Int32 valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.(Défini par Enumerable.)

System_CAPS_pubmethodAverage<Char>(Func<Char, Nullable<Int64>>)

Surchargé. Calcule la moyenne d’une séquence de type nullable Int64 valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.(Défini par Enumerable.)

System_CAPS_pubmethodAverage<Char>(Func<Char, Nullable<Single>>)

Surchargé. Calcule la moyenne d’une séquence de type nullable Single valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.(Défini par Enumerable.)

System_CAPS_pubmethodAverage<Char>(Func<Char, Single>)

Surchargé. Calcule la moyenne d’une séquence de Single valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.(Défini par Enumerable.)

System_CAPS_pubmethodCast<TResult>()

Convertit les éléments d’un IEnumerable au type spécifié.(Défini par Enumerable.)

System_CAPS_pubmethodConcat<Char>(IEnumerable<Char>)

Concatène deux séquences.(Défini par Enumerable.)

System_CAPS_pubmethodContains<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.)

System_CAPS_pubmethodContains<Char>(Char, IEqualityComparer<Char>)

Surchargé. Détermine si une séquence contient un élément spécifié en utilisant un IEqualityComparer<T>.(Défini par Enumerable.)

System_CAPS_pubmethodCount<Char>()

Surchargé. Retourne le nombre d’éléments dans une séquence.(Défini par Enumerable.)

System_CAPS_pubmethodCount<Char>(Func<Char, Boolean>)

Surchargé. Retourne un nombre qui représente le nombre d’éléments dans la séquence spécifiée qui satisfont à une condition.(Défini par Enumerable.)

System_CAPS_pubmethodDefaultIfEmpty<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.)

System_CAPS_pubmethodDefaultIfEmpty<Char>(Char)

Surchargé. Retourne les éléments de la séquence spécifiée ou la valeur spécifiée dans une collection de singletons si la séquence est vide.(Défini par Enumerable.)

System_CAPS_pubmethodDistinct<Char>()

Surchargé. Retourne des éléments distincts d’une séquence à l’aide du comparateur d’égalité par défaut pour comparer les valeurs.(Défini par Enumerable.)

System_CAPS_pubmethodDistinct<Char>(IEqualityComparer<Char>)

Surchargé. Retourne des éléments distincts d’une séquence en utilisant un IEqualityComparer<T> pour comparer des valeurs.(Défini par Enumerable.)

System_CAPS_pubmethodElementAt<Char>(Int32)

Retourne l’élément à l’index spécifié dans une séquence.(Défini par Enumerable.)

System_CAPS_pubmethodElementAtOrDefault<Char>(Int32)

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.)

System_CAPS_pubmethodExcept<Char>(IEnumerable<Char>)

Surchargé. Produit la différence définie entre deux séquences à l’aide du comparateur d’égalité par défaut pour comparer les valeurs.(Défini par Enumerable.)

System_CAPS_pubmethodExcept<Char>(IEnumerable<Char>, IEqualityComparer<Char>)

Surchargé. Produit la différence définie entre deux séquences en utilisant le IEqualityComparer<T> pour comparer des valeurs.(Défini par Enumerable.)

System_CAPS_pubmethodFirst<Char>()

Surchargé. Retourne le premier élément d’une séquence.(Défini par Enumerable.)

System_CAPS_pubmethodFirst<Char>(Func<Char, Boolean>)

Surchargé. Retourne le premier élément d’une séquence à satisfaire à la condition spécifiée.(Défini par Enumerable.)

System_CAPS_pubmethodFirstOrDefault<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.)

System_CAPS_pubmethodFirstOrDefault<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.)

System_CAPS_pubmethodGroupBy<Char, TKey>(Func<Char, TKey>)

Surchargé. Regroupe les éléments d’une séquence selon une fonction de sélection de clé spécifiée.(Défini par Enumerable.)

System_CAPS_pubmethodGroupBy<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)

Surchargé. Regroupe les éléments d’une séquence selon une fonction de sélection de clé spécifiée et compare les clés à l’aide du comparateur spécifié.(Défini par Enumerable.)

System_CAPS_pubmethodGroupBy<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)

Surchargé. Regroupe les éléments d’une séquence selon une fonction de sélection de clé spécifiée et projette les éléments de chaque groupe à l’aide d’une fonction spécifiée.(Défini par Enumerable.)

System_CAPS_pubmethodGroupBy<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.)

System_CAPS_pubmethodGroupBy<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.)

System_CAPS_pubmethodGroupBy<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.)

System_CAPS_pubmethodGroupBy<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.)

System_CAPS_pubmethodGroupBy<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.)

System_CAPS_pubmethodGroupJoin<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.)

System_CAPS_pubmethodGroupJoin<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> est utilisé pour comparer les clés.(Défini par Enumerable.)

System_CAPS_pubmethodIntersect<Char>(IEnumerable<Char>)

Surchargé. Produit l’intersection définie de deux séquences à l’aide du comparateur d’égalité par défaut pour comparer les valeurs.(Défini par Enumerable.)

System_CAPS_pubmethodIntersect<Char>(IEnumerable<Char>, IEqualityComparer<Char>)

Surchargé. Produit l’intersection définie de deux séquences en utilisant le IEqualityComparer<T> pour comparer des valeurs.(Défini par Enumerable.)

System_CAPS_pubmethodJoin<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 selon des clés correspondantes. Le comparateur d'égalité par défaut est utilisé pour comparer les clés.(Défini par Enumerable.)

System_CAPS_pubmethodJoin<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 selon des clés correspondantes. Un IEqualityComparer<T> est utilisé pour comparer les clés.(Défini par Enumerable.)

System_CAPS_pubmethodLast<Char>()

Surchargé. Retourne le dernier élément d’une séquence.(Défini par Enumerable.)

System_CAPS_pubmethodLast<Char>(Func<Char, Boolean>)

Surchargé. Retourne le dernier élément d’une séquence à satisfaire à la condition spécifiée.(Défini par Enumerable.)

System_CAPS_pubmethodLastOrDefault<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.)

System_CAPS_pubmethodLastOrDefault<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.)

System_CAPS_pubmethodLongCount<Char>()

Surchargé. Retourne un Int64 qui représente le nombre total d’éléments dans une séquence.(Défini par Enumerable.)

System_CAPS_pubmethodLongCount<Char>(Func<Char, Boolean>)

Surchargé. Retourne un Int64 qui représente le nombre d’éléments dans une séquence remplissent une condition.(Défini par Enumerable.)

System_CAPS_pubmethodMax<Char>()

Surchargé. Retourne la valeur maximale dans une séquence générique.(Défini par Enumerable.)

System_CAPS_pubmethodMax<Char>(Func<Char, Decimal>)

Surchargé. Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur maximale Decimal valeur.(Défini par Enumerable.)

System_CAPS_pubmethodMax<Char>(Func<Char, Double>)

Surchargé. Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur maximale Double valeur.(Défini par Enumerable.)

System_CAPS_pubmethodMax<Char>(Func<Char, Int32>)

Surchargé. Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur maximale Int32 valeur.(Défini par Enumerable.)

System_CAPS_pubmethodMax<Char>(Func<Char, Int64>)

Surchargé. Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur maximale Int64 valeur.(Défini par Enumerable.)

System_CAPS_pubmethodMax<Char>(Func<Char, Nullable<Decimal>>)

Surchargé. Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur maximale nullable Decimal valeur.(Défini par Enumerable.)

System_CAPS_pubmethodMax<Char>(Func<Char, Nullable<Double>>)

Surchargé. Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur maximale nullable Double valeur.(Défini par Enumerable.)

System_CAPS_pubmethodMax<Char>(Func<Char, Nullable<Int32>>)

Surchargé. Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur maximale nullable Int32 valeur.(Défini par Enumerable.)

System_CAPS_pubmethodMax<Char>(Func<Char, Nullable<Int64>>)

Surchargé. Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur maximale nullable Int64 valeur.(Défini par Enumerable.)

System_CAPS_pubmethodMax<Char>(Func<Char, Nullable<Single>>)

Surchargé. Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur maximale nullable Single valeur.(Défini par Enumerable.)

System_CAPS_pubmethodMax<Char>(Func<Char, Single>)

Surchargé. Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur maximale Single valeur.(Défini par Enumerable.)

System_CAPS_pubmethodMax<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.)

System_CAPS_pubmethodMin<Char>()

Surchargé. Retourne la valeur minimale dans une séquence générique.(Défini par Enumerable.)

System_CAPS_pubmethodMin<Char>(Func<Char, Decimal>)

Surchargé. Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur minimale Decimal valeur.(Défini par Enumerable.)

System_CAPS_pubmethodMin<Char>(Func<Char, Double>)

Surchargé. Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur minimale Double valeur.(Défini par Enumerable.)

System_CAPS_pubmethodMin<Char>(Func<Char, Int32>)

Surchargé. Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur minimale Int32 valeur.(Défini par Enumerable.)

System_CAPS_pubmethodMin<Char>(Func<Char, Int64>)

Surchargé. Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur minimale Int64 valeur.(Défini par Enumerable.)

System_CAPS_pubmethodMin<Char>(Func<Char, Nullable<Decimal>>)

Surchargé. Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur minimale nullable Decimal valeur.(Défini par Enumerable.)

System_CAPS_pubmethodMin<Char>(Func<Char, Nullable<Double>>)

Surchargé. Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur minimale nullable Double valeur.(Défini par Enumerable.)

System_CAPS_pubmethodMin<Char>(Func<Char, Nullable<Int32>>)

Surchargé. Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur minimale nullable Int32 valeur.(Défini par Enumerable.)

System_CAPS_pubmethodMin<Char>(Func<Char, Nullable<Int64>>)

Surchargé. Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur minimale nullable Int64 valeur.(Défini par Enumerable.)

System_CAPS_pubmethodMin<Char>(Func<Char, Nullable<Single>>)

Surchargé. Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur minimale nullable Single valeur.(Défini par Enumerable.)

System_CAPS_pubmethodMin<Char>(Func<Char, Single>)

Surchargé. Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur minimale Single valeur.(Défini par Enumerable.)

System_CAPS_pubmethodMin<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.)

System_CAPS_pubmethodOfType<TResult>()

Filtre les éléments d’un IEnumerable basé sur un type spécifié.(Défini par Enumerable.)

System_CAPS_pubmethodOrderBy<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.)

System_CAPS_pubmethodOrderBy<Char, TKey>(Func<Char, TKey>, IComparer<TKey>)

Surchargé. Trie les éléments d’une séquence dans l’ordre croissant à l’aide du comparateur spécifié.(Défini par Enumerable.)

System_CAPS_pubmethodOrderByDescending<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.)

System_CAPS_pubmethodOrderByDescending<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.)

System_CAPS_pubmethodReverse<Char>()

Inverse l’ordre des éléments dans une séquence.(Défini par Enumerable.)

System_CAPS_pubmethodSelect<Char, TResult>(Func<Char, TResult>)

Surchargé. Projette chaque élément d’une séquence dans un nouveau formulaire.(Défini par Enumerable.)

System_CAPS_pubmethodSelect<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.)

System_CAPS_pubmethodSelectMany<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.)

System_CAPS_pubmethodSelectMany<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.)

System_CAPS_pubmethodSelectMany<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électeur de résultat sur chaque élément inclus.(Défini par Enumerable.)

System_CAPS_pubmethodSelectMany<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électeur 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.)

System_CAPS_pubmethodSequenceEqual<Char>(IEnumerable<Char>)

Surchargé. Détermine si deux séquences sont égales en comparant les éléments à l’aide du comparateur d’égalité par défaut pour ce type.(Défini par Enumerable.)

System_CAPS_pubmethodSequenceEqual<Char>(IEnumerable<Char>, IEqualityComparer<Char>)

Surchargé. Détermine si deux séquences sont égales en comparant leurs éléments en utilisant un IEqualityComparer<T>.(Défini par Enumerable.)

System_CAPS_pubmethodSingle<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 et unique élément. (Défini par Enumerable.)

System_CAPS_pubmethodSingle<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.)

System_CAPS_pubmethodSingleOrDefault<Char>()

Surchargé. Retourne le seul élément d’une séquence ou une valeur par défaut si la séquence est vide ; Cette méthode lève une exception s’il existe plusieurs éléments dans la séquence.(Défini par Enumerable.)

System_CAPS_pubmethodSingleOrDefault<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.)

System_CAPS_pubmethodSkip<Char>(Int32)

Ignore un nombre spécifié d’éléments dans une séquence et puis retourne les éléments restants.(Défini par Enumerable.)

System_CAPS_pubmethodSkipWhile<Char>(Func<Char, Boolean>)

Surchargé. Ignore les éléments d’une séquence tant qu’une condition spécifiée a la valeur true, puis retourne les éléments restants.(Défini par Enumerable.)

System_CAPS_pubmethodSkipWhile<Char>(Func<Char, Int32, Boolean>)

Surchargé. Ignore les éléments d’une séquence tant qu’une 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.)

System_CAPS_pubmethodSum<Char>(Func<Char, Decimal>)

Surchargé. Calcule la somme de la séquence de Decimal valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.(Défini par Enumerable.)

System_CAPS_pubmethodSum<Char>(Func<Char, Double>)

Surchargé. Calcule la somme de la séquence de Double valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.(Défini par Enumerable.)

System_CAPS_pubmethodSum<Char>(Func<Char, Int32>)

Surchargé. Calcule la somme de la séquence de Int32 valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.(Défini par Enumerable.)

System_CAPS_pubmethodSum<Char>(Func<Char, Int64>)

Surchargé. Calcule la somme de la séquence de Int64 valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.(Défini par Enumerable.)

System_CAPS_pubmethodSum<Char>(Func<Char, Nullable<Decimal>>)

Surchargé. Calcule la somme de la séquence de nullable Decimal valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.(Défini par Enumerable.)

System_CAPS_pubmethodSum<Char>(Func<Char, Nullable<Double>>)

Surchargé. Calcule la somme de la séquence de nullable Double valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.(Défini par Enumerable.)

System_CAPS_pubmethodSum<Char>(Func<Char, Nullable<Int32>>)

Surchargé. Calcule la somme de la séquence de nullable Int32 valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.(Défini par Enumerable.)

System_CAPS_pubmethodSum<Char>(Func<Char, Nullable<Int64>>)

Surchargé. Calcule la somme de la séquence de nullable Int64 valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.(Défini par Enumerable.)

System_CAPS_pubmethodSum<Char>(Func<Char, Nullable<Single>>)

Surchargé. Calcule la somme de la séquence de nullable Single valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.(Défini par Enumerable.)

System_CAPS_pubmethodSum<Char>(Func<Char, Single>)

Surchargé. Calcule la somme de la séquence de Single valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.(Défini par Enumerable.)

System_CAPS_pubmethodTake<Char>(Int32)

Retourne un nombre spécifié d’éléments contigus à partir du début d’une séquence.(Défini par Enumerable.)

System_CAPS_pubmethodTakeWhile<Char>(Func<Char, Boolean>)

Surchargé. Retourne des éléments d’une séquence tant qu’une condition spécifiée a la valeur true.(Défini par Enumerable.)

System_CAPS_pubmethodTakeWhile<Char>(Func<Char, Int32, Boolean>)

Surchargé. Retourne des éléments d’une séquence tant qu’une 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.)

System_CAPS_pubmethodToArray<Char>()

Crée un tableau d’un IEnumerable<T>.(Défini par Enumerable.)

System_CAPS_pubmethodToDictionary<Char, TKey>(Func<Char, TKey>)

Surchargé. Crée un Dictionary<TKey, TValue> d’un IEnumerable<T> selon une fonction de sélection de clé spécifiée.(Défini par Enumerable.)

System_CAPS_pubmethodToDictionary<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)

Surchargé. Crée un Dictionary<TKey, TValue> d’un IEnumerable<T> selon un comparateur de fonction et la clé de sélection de clé spécifiée.(Défini par Enumerable.)

System_CAPS_pubmethodToDictionary<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)

Surchargé. Crée un Dictionary<TKey, TValue> d’un IEnumerable<T> en fonction de sélection de clé spécifiée et les fonctions de sélecteur d’élément.(Défini par Enumerable.)

System_CAPS_pubmethodToDictionary<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)

Surchargé. Crée un Dictionary<TKey, TValue> d’un 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.)

System_CAPS_pubmethodToList<Char>()

Crée un List<T> d’un IEnumerable<T>.(Défini par Enumerable.)

System_CAPS_pubmethodToLookup<Char, TKey>(Func<Char, TKey>)

Surchargé. Crée un Lookup<TKey, TElement> d’un IEnumerable<T> selon une fonction de sélection de clé spécifiée.(Défini par Enumerable.)

System_CAPS_pubmethodToLookup<Char, TKey>(Func<Char, TKey>, IEqualityComparer<TKey>)

Surchargé. Crée un Lookup<TKey, TElement> d’un IEnumerable<T> selon un comparateur de fonction et la clé de sélection de clé spécifiée.(Défini par Enumerable.)

System_CAPS_pubmethodToLookup<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>)

Surchargé. Crée un Lookup<TKey, TElement> d’un IEnumerable<T> en fonction de sélection de clé spécifiée et les fonctions de sélecteur d’élément.(Défini par Enumerable.)

System_CAPS_pubmethodToLookup<Char, TKey, TElement>(Func<Char, TKey>, Func<Char, TElement>, IEqualityComparer<TKey>)

Surchargé. Crée un Lookup<TKey, TElement> d’un 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.)

System_CAPS_pubmethodUnion<Char>(IEnumerable<Char>)

Surchargé. Produit l’union définie de deux séquences à l’aide du comparateur d’égalité par défaut.(Défini par Enumerable.)

System_CAPS_pubmethodUnion<Char>(IEnumerable<Char>, IEqualityComparer<Char>)

Surchargé. Produit l’union définie de deux séquences en utilisant un IEqualityComparer<T>.(Défini par Enumerable.)

System_CAPS_pubmethodWhere<Char>(Func<Char, Boolean>)

Surchargé. Filtre une séquence de valeurs selon un prédicat.(Défini par Enumerable.)

System_CAPS_pubmethodWhere<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.)

System_CAPS_pubmethodZip<Char, TSecond, TResult>(IEnumerable<TSecond>, Func<Char, TSecond, TResult>)

Applique une fonction spécifiée aux éléments correspondants de deux séquences, produire une séquence de résultats.(Défini par Enumerable.)

System_CAPS_noteRemarque

Pour afficher le code source de .NET Framework pour ce type, consultez la Reference Source. Vous pouvez parcourir le code source en ligne, télécharger la référence de consultation hors connexion et parcourir les sources (y compris les correctifs et mises à jour) pendant le débogage ; see instructions.

Une chaîne est une collection séquentielle de caractères qui est utilisée pour représenter du texte. A String objet est une collection séquentielle de System.Char des objets qui représentent une chaîne, un System.Char objet correspond à une unité de code UTF-16. La valeur de la String objet est le contenu de la collection séquentielle de System.Char objets, et que la valeur est immuable (autrement dit, il est en lecture seule). Pour plus d’informations sur l’immuabilité des chaînes, consultez le immuabilité et la classe StringBuilder section plus loin dans cette rubrique. La taille maximale d’un String objet en mémoire est de 2 Go ou environ 1 milliard de caractères.

Dans cette section :

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

Vous pouvez instancier un String objet comme suit :

  • En assignant un littéral de chaîne en un String variable. Il s’agit de la méthode la plus couramment utilisée pour la création d’une chaîne. L’exemple suivant utilise l’attribution à créer plusieurs chaînes. Notez que dans 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 échappés ou la chaîne entière doit être entre guillemets.

    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 String constructeur de classe. 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 en tant que paramètres. Visual Basic ne prend pas en charge les appels à ces constructeurs. Pour plus d’informations sur les String constructeurs, consultez la String résumé du constructeur.

    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  
    
  • À l’aide de l’opérateur de concaténation (+ en c# et s’ou + en Visual Basic) pour créer une chaîne unique à partir de n’importe quelle combinaison de String instances et les littéraux de chaîne. L’exemple suivant illustre l’utilisation de l’opérateur de concaténation de chaîne.

    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 String classe pour extraire une sous-chaîne d’une chaîne plus grande.

    string sentence = "This sentence has five words.";
    // Extract the second word.
    int startPosition = sentence.IndexOf(" ") + 1;
    string word2 = sentence.Substring(startPosition,
                                      sentence.IndexOf(" ", startPosition) - startPosition);
    Console.WriteLine("Second word: " + word2);
    // The example displays the following output:
    //       Second word: sentence
    
  • 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 le mise en forme composite fonctionnalité pour incorporer 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.      
    

Chaque caractère dans une chaîne est défini par une valeur scalaire Unicode, également appelée point de code Unicode ou la 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 Char objet.

System_CAPS_noteRemarque

Notez que, car un String instance se compose d’une collection séquentielle d’unités de code UTF-16, il est possible de créer un String objet qui n’est pas une chaîne Unicode bien formée. Par exemple, il est possible de créer une chaîne qui possède un substitut faible sans un substitut correspondant. Bien que certaines méthodes, telles que les méthodes de codage et décodage d’objets dans le System.Text espace de noms peut effectue des vérifications pour vous assurer que les chaînes sont bien formées, String membres de classe ne garantissent pas qu’une chaîne est bien formée.

Un seul Char objet représente généralement un seul point de code, autrement dit, la valeur numérique de la Char est égale au point de code. Par exemple, le point de code pour le caractère « a » est U + 0061. Toutefois, un point de code peut nécessiter plusieurs éléments encodés (plusieurs Char objet). La norme Unicode définit deux types de caractères qui correspondent à plusieurs Char objets : graphèmes et les points de code supplémentaires Unicode qui correspondent aux caractères dans les plans supplémentaires Unicode.

  • Un groupes de graphèmes 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 Char objet dont le point de code est U + 0061, suivi par un Char objet dont le point de code est U + 0308. Ce caractère peut également être défini par un seul Char objet qui a un point de code de U + 00E4. Comme le montre l’exemple suivant, une comparaison dépendante de la culture d’égalité indique que ces deux représentations sont égales, même si n’est pas le cas d’une comparaison ordinale ordinaire. Toutefois, si les deux chaînes sont normalisées, une comparaison ordinale indique également qu’ils sont égaux. (Pour plus d’informations sur la normalisation de chaînes, consultez le normalisation section.)

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

Caractères dans une chaîne sont représentés par des unités de code encodée en UTF-16, qui correspondent aux Char valeurs.

Chaque caractère d’une chaîne a une catégorie de caractères Unicode associée, qui est représentée dans le .NET Framework par la UnicodeCategory énumération. La catégorie d’un caractère ou une paire de substitution peut être déterminée en appelant le CharUnicodeInfo.GetUnicodeCategory (méthode).

Le .NET Framework gère sa propre table des caractères et leurs catégories correspondants, ce qui garantit qu’une version du .NET Framework en cours d’exécution sur différentes plateformes retourne des informations de catégorie de caractères identiques. Le tableau suivant répertorie les versions du .NET Framework et les versions de la norme Unicode sur lesquelles reposent les catégories de caractères.

Version du .NET Framework

Version de la norme Unicode

.NET Framework 1.1

The Unicode Standard, Version 4.0.0

Le .NET Framework 2.0

The Unicode Standard, Version 5.0.0

.NET Framework 3.5

The Unicode Standard, Version 5.0.0

.NET Framework 4

The Unicode Standard, Version 5.0.0

.NET Framework 4.5

The Unicode Standard, Version 6.3.0

.NET Framework 4.5.1

The Unicode Standard, Version 6.3.0

.NET Framework 4.5.2

The Unicode Standard, Version 6.3.0

.NET Framework 4.6

The Unicode Standard, Version 6.3.0

.NET Framework 4.6.1

The Unicode Standard, Version 6.3.0

.NET Framework 4.6.2

The Unicode Standard, Version 8.0.0

En outre, le .NET Framework prend en charge la comparaison de chaînes et le tri basé sur la norme Unicode. Dans les versions du .NET Framework via le .NET Framework 4, le .NET Framework gère sa propre table des données de chaîne. Cela vaut également pour des versions du .NET Framework en commençant par le .NET Framework 4.5 s’exécutant sur Windows 7. En commençant par le .NET Framework 4.5 en cours d’exécution sur Windows 8 et versions ultérieures du système d’exploitation Windows, les délégués de l’exécution de chaîne comparaison et tri des opérations du système d’exploitation. Le tableau suivant répertorie les versions du .NET Framework et les versions de la norme Unicode sur le caractère de comparaison et tri sont basées.

Version du .NET Framework

Version de la norme Unicode

.NET Framework 1.1

The Unicode Standard, Version 4.0.0

Le .NET Framework 2.0

The Unicode Standard, Version 5.0.0

.NET Framework 3.5

The Unicode Standard, Version 5.0.0

.NET Framework 4

The Unicode Standard, Version 5.0.0

.NET Framework 4.5et versions ultérieures de Windows 7

The Unicode Standard, Version 5.0.0

.NET Framework 4.5et versions ultérieures de Windows 8 et ultérieures

The Unicode Standard, Version 6.3.0

Dans le .NET Framework, un String objet peut inclure des caractères null incorporés, qui comptent dans la longueur de chaîne. Toutefois, dans certains langages tels que C et C++, un caractère null indique la fin d’une chaîne ; il n’est pas considéré comme une partie de la chaîne et n’est pas compté dans le cadre de la longueur de chaîne. Cela signifie que les hypothèses courantes suivantes, les programmeurs C et C++ ou écrites en C ou C++ qui peuvent être sur les chaînes ne sont pas nécessairement valides lorsqu’il est appliqué à String objets :

  • La valeur retournée par la strlen ou wcslen fonctions n’est pas nécessairement égal String.Length.

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

Vous devez vous assurer que code C et C++ natif qui instancie String objets et le code qui est passé String objets via la plateforme de code non managé, ne supposez 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 lorsqu’une chaîne est triée (ou comparée) et lorsqu’une chaîne de recherche est effectué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 des comparaisons à l’aide de la culture dite indifférente. Elles sont considérées comme uniquement pour les comparaisons ordinales ordinales ou non la casse. En revanche, les caractères null incorporés sont toujours considérées comme lors de la recherche d’une chaîne avec des méthodes telles que Contains, StartsWith, et IndexOf.

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

Le Chars propriété vous permet d’accéder à des Char les objets par leur position d’index dans la chaîne. Étant donné que la Chars propriété est la propriété par défaut (en Visual Basic) ou l’indexeur (en c#), vous pouvez accéder à la personne Char objets dans une chaîne en utilisant le code suivant. Ce code recherche des espaces blancs ou des caractères de ponctuation dans une chaîne pour déterminer la chaîne contient le nombre de mots.

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.

Car le String la classe implémente la IEnumerable interface, vous pouvez également itérer la Char objets dans une chaîne à l’aide un foreach construction, comme le montre 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.

Valeurs d’index consécutives ne peuvent pas correspondre à des caractères Unicode consécutifs, car un caractère peut être encodé en Unicode de plusieurs Char objet. En particulier, une chaîne peut contenir plusieurs caractères unités de texte qui sont formées par un caractère de base suivi par un ou plusieurs caractères d’association ou par les paires de substitution. Pour travailler avec des caractères Unicode à la place de Char objets, utilisez la System.Globalization.StringInfo et TextElementEnumerator classes. L’exemple suivant illustre la différence entre le code qui fonctionne avec Char objets et du code qui fonctionne avec des caractères Unicode. Il compare le nombre de caractères ou des éléments de texte de chaque mot d’une phrase. La chaîne inclut deux séquences d’un caractère de base suivi 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 les éléments de texte à l’aide de la StringInfo.GetTextElementEnumerator (méthode) et la TextElementEnumerator classe 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 le StringInfo.ParseCombiningCharacters (méthode).

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

Une chaîne qui a été déclarée mais n’a pas été attribuée une valeur est null. Toute tentative d’appel de 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, en passant une chaîne null ou une chaîne vide en tant qu’argument dans un appel de méthode lève une exception. Par exemple, en passant une chaîne null pour le Int32.Parse méthode lève une exception une ArgumentNullExceptionet en passant une chaîne vide lève une FormatException. Dans d’autres cas, un argument de méthode peut être une chaîne null ou une chaîne vide. Par exemple, si vous fournissez un IFormattable implémentation pour une classe, doivent correspondre à la fois une chaîne null et une chaîne vide avec le spécificateur de format général (« G »).

Le String classe 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 du code semblable au suivant :

    if (str == null || str.Equals(String.Empty))
    
  • IsNullOrWhiteSpace, qui indique si une chaîne est null, est égal à String.Empty, ou est composé exclusivement d’espaces blancs. Cette méthode élimine le besoin d’utiliser du code semblable au suivant :

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

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

A String objet est appelé immuable (lecture seule), car sa valeur ne peut pas être modifiée une fois qu’elle a été créée. Les méthodes qui semblent modifier un String objet réellement retournent un nouvel String objet qui contient la modification.

Étant donné que les chaînes sont immuables, les routines de manipulation de chaîne qui effectuent des répété ajouts ou suppressions à ce qui semble être qu'une chaîne unique peut peser une baisse significative des performances. Par exemple, le code suivant utilise un générateur de nombres aléatoires pour créer une chaîne avec 1 000 caractères dans la plage 0 x 0001 à 0x052F. Bien que le code s’affiche à la concaténation de chaînes permet d’ajouter un nouveau caractère à la chaîne existante nommée str, elle crée un nouveau String objet 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 StringBuilder classe au lieu du String classe pour les opérations qui apportent plusieurs modifications à la valeur d’une chaîne. Contrairement aux instances de la String (classe), StringBuilder objets sont mutables ; lorsque vous concaténez, ajoutez ou supprimez des sous-chaînes d’une chaîne, les opérations sont effectuées sur une seule chaîne. Lorsque vous avez terminé de modifier la valeur d’un StringBuilder de l’objet, vous pouvez appeler son StringBuilder.ToString méthode pour le convertir en une chaîne. L’exemple suivant remplace le String utilisé dans l’exemple précédent pour concaténer les 1000 de caractères aléatoires dans la plage de 0 x 0001 à 0x052F avec un StringBuilder objet.

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

Membres de la String classe opérations ordinales ou dépendantes de la culture (linguistique) sur un String objet. Une opération ordinale agit sur la valeur numérique de chaque Char objet. A lieu une opération dépendante de la culture de la valeur de la Stringobjet et prend la casse spécifiques à la culture, le tri, de mise en forme et règles d’analyse en compte. Les opérations dépendantes de la culture s’exécutent 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.

Le .NET Framework prend également en charge les opérations de chaînes linguistique indépendante de la culture à l’aide de la culture dite indifférente (CultureInfo.InvariantCulture), qui est faiblement basé sur les paramètres de culture de la langue anglaise indépendante de la région. Contrairement à d’autres System.Globalization.CultureInfo sont garanti que les paramètres, les paramètres de la culture dite indifférente restent cohérentes sur un seul ordinateur, à partir du système au système et entre les versions du .NET Framework. La culture dite indifférente peut être considéré comme étant un type de zone noire qui garantit la stabilité des comparaisons de chaînes et de tri dans toutes les cultures.

System_CAPS_security Sécurité Remarque

Si votre application prend une décision de sécurité sur un identificateur symbolique tel qu’un nom de fichier ou canal nommé, ou des données rendues persistantes telles que les données textuelles dans un fichier XML, l’opération doit utiliser une comparaison ordinale au lieu d’une comparaison dépendante de la culture. Il s’agit, car une comparaison dépendante de la culture peut produire des résultats différents selon la culture en vigueur, tandis qu’une comparaison ordinale dépend uniquement de la valeur binaire des caractères comparés.

System_CAPS_importantImportant

La plupart des méthodes qui effectuent des opérations de chaîne incluent une surcharge qui a un paramètre de type StringComparison, ce qui vous permet de spécifier si la méthode effectue une opération ordinale ou dépendante de la culture. En règle générale, vous devez appeler cette surcharge pour appeler l’intention de votre méthode clear. Pour les meilleures pratiques et les instructions d’utilisation des ordinale et dépendante de la culture des opérations sur les chaînes, consultez Meilleures pratiques pour l'utilisation de chaînes dans le .NET Framework.

Opérations pour casse, l’analyse et de mise en forme, comparaison et tri, et test d’égalité peut être ordinale ou dépendante de la culture. Les sections suivantes décrivent chaque catégorie d’opération.

System_CAPS_tipAstuce

Vous devez toujours appeler une surcharge de méthode qui appelle l’intention de votre méthode clear. Par exemple, au lieu d’appeler le Compare(String, String) méthode pour effectuer une comparaison dépendante de la culture de deux chaînes en utilisant les conventions de la culture actuelle, vous devez appeler la Compare(String, String, StringComparison) méthode avec la valeur StringComparison.CurrentCulture pour la comparisonType argument. Pour plus d'informations, consultez Meilleures pratiques pour l'utilisation de chaînes dans le .NET Framework.

Règles de casse déterminent comment modifier la mise en majuscules d’un caractère Unicode ; par exemple, de 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 majuscules afin qu’elle peut être comparée avec une autre chaîne en majuscules. Vous pouvez convertir les caractères dans une chaîne en minuscules en appelant le ToLower ou ToLowerInvariant (méthode) et que vous pouvez convertir en majuscules en appelant le ToUpper ou ToUpperInvariant (méthode). En outre, vous pouvez utiliser la TextInfo.ToTitleCase méthode pour convertir une chaîne en majuscule.

Opérations de la casse peuvent reposer sur les règles de la culture actuelle, une culture spécifiée ou la culture dite indifférente. Étant donné que les mappages de casse peuvent varier en fonction de la culture utilisée, le résultat des opérations de casse peut varier en fonction de la culture. Il existe trois types de différences réelles de la casse :

  • Les différences dans le mappage de casse de lettre majuscule de LATIN I (U + 0049), LATIN petite lettre I (U + 0069), LATIN lettre majuscule I avec point en chef (U + 0130) et LATIN petite lettre sans point I (U + 0131). Dans le tr-TR (turc (Turquie)) et cultures de az-Latn-AZ (Azerbaïdjan, Latin) et dans les tr, az et az-Latn les cultures neutres, l’équivalent en minuscule de lettre majuscule latine I est LATIN petite lettre sans point I et est de l’équivalent en majuscule latine de petite lettre i MAJUSCULE LATIN I avec point ci-dessus. Dans tous les autres cultures, y compris la culture dite indifférente, LATIN petite lettre I et MAJUSCULE LATIN I sont équivalents majuscules et minuscules.

    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 s’appuie sur une comparaison dépendante de la culture la 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 dans les mappages de casse entre tous les autres cultures et de la culture dite indifférente. Dans ce cas, à l’aide des règles de casse de la culture dite indifférente pour modifier un caractère en majuscules ou minuscules retourne le même caractère. Pour toutes les autres cultures, il retourne un caractère différent. Certains caractères concernés sont répertoriés dans le tableau suivant.

    Caractère

    Si vous en

    Returns (Retours)

    TECHNIQUE SIGNE (U + 00B5)

    Majuscules

    LETTRE MAJUSCULE GRECQUE MU (U +-39C)

    LETTRE MAJUSCULE LATINE I POINT CI-DESSUS (U + 0130)

    Minuscules

    LETTRE MINUSCULE LATINE I (U + 0069)

    LETTRE MINUSCULE LATINE SANS POINT I (U + 0131)

    Majuscules

    LETTRE MAJUSCULE LATINE I (U + 0049)

    LETTRE MINUSCULE LATINE LONG S (U + 017F)

    Majuscules

    LETTRE MAJUSCULE LATINE S (U + 0053)

    LETTRE MAJUSCULE LATINE D Z LETTRE MINUSCULE AVEC CARON (U + 01C 5)

    Minuscules

    LETTRE MINUSCULE LATINE DZ CARON (U + 01C 6)

    COMBINAISON GREC IOTA SOUSCRIT (U + 0345)

    Majuscules

    LETTRE MAJUSCULE GRECQUE IOTA (U + 0399)

  • Différences dans les mappages de casse de paires de casse mixte de deux lettres dans la plage de caractères ASCII. Dans la plupart des cultures, une paire de casse mixte de deux lettres est égale à la paire de caractères majuscule ou minuscule équivalente à deux lettres. Cela n’est pas vrai pour les paires de deux lettres suivantes dans les cultures suivantes, car dans chaque cas, elles sont comparées à un digramme :

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

    • « cH » dans cs-CZ (tchèque (République tchèque)) et cultures de sk-SK (slovaque (Slovaquie)).

    • « aA » dans la culture da-DK (Danois (Danemark)).

    • « cS », « dZ », « dZS », « nY », « sZ », « réessayer » et « zS » dans la culture hu-HU (hongrois (Hongrie)).

    • « cH » et « lL » dans la culture es-ES_tradnl (espagnol (Espagne, traditionnel)).

    • « cH », « gI », « kH », « nG », « nH », « pH », « qU », « tH » et « tR » dans la culture vi-VN (vietnamien (Vietnam)).

    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, étant donné que ces paires sont rares dans les identificateurs ni les chaînes fixes.

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

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 

Mise en forme et l’analyse sont des opérations inverses. Règles de mise en forme déterminent comment convertir une valeur, comme une date et d’heure ou d’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. Mise en forme et de règles d’analyse sont dépendantes des conventions culturelles. L’exemple suivant illustre l’ambiguïté qui peut survenir lors de l’interprétation d’une chaîne de date spécifique à la culture. Sans connaître les conventions de la culture utilisée pour générer une chaîne 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

De même, comme le montre l’exemple suivant, une chaîne unique peut produire des dates différentes selon 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

Conventions pour comparer et trier des chaînes varient d’une culture. Par exemple, l’ordre de tri peut être basé sur phonétique ou sur la représentation visuelle de caractères. Dans les langues d'Asie orientale, les caractères sont classés en fonction du trait et de la clé des idéogrammes. Le tri peut aussi varier en fonction de l'ordre fondamental utilisé par la langue ou la culture pour l'alphabet. Par exemple, la langue danoise emploie un caractère "Æ" qu'elle place après "Z" dans l'alphabet. En outre, les comparaisons peuvent respecter la casse, et dans certains cas, les règles de casse diffèrent également selon la culture. Comparaison ordinale, utilise en revanche, les points de code Unicode des caractères dans une chaîne lors de la comparaison et tri des chaînes.

Les règles de tri déterminent que l’ordre alphabétique des caractères Unicode et la manière dont deux chaînes comparent. Par exemple, le String.Compare(String, String, StringComparison) méthode compare deux chaînes selon les StringComparison paramètre. Si la valeur du 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 le montre l’exemple suivant, si la culture actuelle est anglais Anglais, le premier appel à la String.Compare(String, String, StringComparison) (méthode) (à 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 » comme 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 mots, des chaînes et des règles de tri ordinal :

  • Un tri word effectue une comparaison dépendante de la culture de chaînes dans lequel certains caractères Unicode non alphanumériques peut-être spéciales poids affectés pour les. Par exemple, le trait d’union (-) peut avoir une très petite pondération affectée à ce dernier afin que « coop » et « op » s’affichent en regard de l’autre dans une liste triée. Pour obtenir la liste de la Stringles méthodes qui permettent de comparer deux chaînes à l’aide des règles de tri de word, consultez le opérations de chaîne par catégorie section.

  • Un tri de chaîne effectue également une comparaison dépendante de la culture. Il est similaire à un tri par mot, sauf qu’il n’y a aucun cas particulier et tous les symboles non alphanumériques sont avant tous les caractères Unicode alphanumériques. Deux chaînes peuvent être comparées à l’aide des règles de tri de chaîne en appelant le CompareInfo.Compare des surcharges de méthode qui ont un options paramètre est fourni 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 des règles de tri de chaîne.

  • Un tri ordinal compare des chaînes en fonction de la valeur numérique de chaque Char objet dans la chaîne. Une comparaison ordinale est 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 dite indifférente et effectuer une comparaison ordinale du résultat. Pour obtenir la liste de la String les méthodes qui permettent de comparer deux chaînes à l’aide des règles de tri ordinal, consultez la opérations de chaîne par catégorie section.

Une comparaison dépendante de la culture est une comparaison qui utilise explicitement ou implicitement un CultureInfo objet, y compris la culture dite indifférente est spécifiée par le CultureInfo.InvariantCulture propriété. La culture implicite est la culture actuelle, qui est spécifiée par le Thread.CurrentCulture et CultureInfo.CurrentCulture propriétés. Il existe des variations considérables dans l’ordre de tri des caractères alphabétiques (autrement dit, les caractères dont la Char.IsLetter propriété renvoie 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 CultureInfo d’objet à une méthode de comparaison de chaîne comme Compare(String, String, CultureInfo, CompareOptions). Vous pouvez spécifier une comparaison dépendante de la culture qui utilise les conventions de la culture actuelle, vous devez fournir StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCase, ou un membre de la CompareOptions énumération autre que CompareOptions.Ordinal ou CompareOptions.OrdinalIgnoreCase à la surcharge appropriée de la Compare (méthode). Une comparaison dépendante de la culture est en général appropriée au tri tandis qu’une comparaison ordinale ne l’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é) alors qu’une comparaison dépendante de la culture n’est pas.

L’exemple suivant illustre la différence entre une comparaison dépendante de la culture et ordinale. L’exemple renvoie trois chaînes « Apple », « Æble » et « AEble », à l’aide de la comparaison ordinale et les conventions des cultures da-DK et en-US (chacun d’eux est la culture par défaut au moment où la Compare méthode est appelée). Étant donné que la langue danoise traite le caractère « Æ » comme une seule lettre et elle place après « Z » dans l’alphabet, la chaîne « Æble » est supérieure à « Apple ». Toutefois, « Æble » n’est pas considéré équivalent à « AEble », « Æble » est également supérieure à « AEble ». La culture en-US ne comprend pas la lettre « Æ », mais la traite comme étant équivalent à « AE », qui explique pourquoi « Æble » est inférieure à « Apple » mais égal à « AEble ». Comparaison ordinale, en revanche, prend en compte que le « Apple » est inférieure à « Æble » et « Æble » est supérieure à « AEble ».

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

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

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

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

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

Pour choisir une méthode de comparaison de tri ou de chaîne appropriée, utilisez les indications suivantes :

  • Si vous souhaitez que les chaînes pour être classés en fonction de la culture de l’utilisateur, vous devez classer les selon les conventions de la culture actuelle. Si la culture change, l’ordre des chaînes de tri modifiera également en conséquence. Par exemple, une application de dictionnaire des synonymes doit toujours trier les mots en fonction de la culture de l’utilisateur.

  • Si vous souhaitez que les chaînes pour être classés selon les conventions d’une culture spécifique, vous devez les classer en fournissant un CultureInfo objet qui représente cette culture à une méthode de comparaison. Par exemple, dans une application conçue pour apprendre les étudiants une langue particulière, vous souhaitez les chaînes pour être classés selon les conventions de l’un des cultures qui lit cette langue.

  • Si vous souhaitez que l’ordre des chaînes à restent inchangés dans toutes les cultures, dans l’ordre selon les conventions de la culture dite indifférente ou si vous utilisez une comparaison ordinale. Par exemple, vous utiliseriez un tri ordinal pour organiser les noms de fichiers, les processus, les mutex, ou les canaux nommés.

  • Pour une comparaison qui implique une décision de sécurité (par exemple, si un nom d’utilisateur est valide), vous devez toujours réaliser un test ordinal pour l’égalité en appelant une surcharge de la Equals (méthode).

System_CAPS_noteRemarque

Le tri de dépendante 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 le .NET Framework 4.5 en cours d’exécution le Windows 8 système d’exploitation, de tri, casse, normalisation et informations sur les caractères Unicode est conforme à la norme Unicode 6.0. Sur les autres systèmes d’exploitation, il est conforme à la norme Unicode 5.0.

Pour plus d’informations sur les mots, des chaînes et des règles de tri ordinal, consultez la System.Globalization.CompareOptions rubrique. Pour des recommandations supplémentaires quand 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 chaîne telles que les méthodes de comparaison Compare directement pour déterminer l’ordre de tri de 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 effectue les quatre opérations de tri différentes (tri des mots à l’aide de la culture actuelle, le tri de word à l’aide de la culture dite indifférente, le tri ordinal et le tri des chaînes à l’aide de la culture dite indifférente) sans appeler explicitement la méthode de comparaison de chaînes, bien qu’ils spécifient le type de comparaison à utiliser. 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
System_CAPS_tipAstuce

En interne,.NET Framework utilise des clés de tri pour prendre en charge la comparaison de chaînes culturallysensitive. Chaque caractère d'une chaîne se voit attribuer plusieurs pondérations de tri, notamment les pondérations alphabétiques, de casse et diacritiques. Une clé de tri, représenté par le SortKey de classe, fournit un référentiel de ces pondérations pour une chaîne particulière. Si votre application effectue un grand nombre d’opérations sur le même ensemble de chaînes de tri ou de recherche, vous pouvez améliorer ses performances en générant et en stockant des clés de tri pour toutes les chaînes qu’il utilise. Lorsqu’une opération de tri ou de comparaison est requise, vous utilisez les clés de tri plutôt que les chaînes. Pour plus d'informations, consultez la classe SortKey.

Si vous ne spécifiez pas une convention de comparaison de chaîne, les méthodes de tri telles que Array.Sort(Array) effectuer un tri dépendantes de la culture, la casse sur les chaînes. L’exemple suivant illustre comment la modification de la culture actuelle affecte l’ordre des chaînes de tri dans un tableau. Il crée un tableau de trois chaînes. D'abord, cela définit la propriété System.Threading.Thread.CurrentThread.CurrentCulture sur la valeur en-US, et appelle la méthode Array.Sort(Array). L’ordre de tri qui en résulte est basée sur le tri des conventions pour la culture anglais (États-Unis). Ensuite, l'exemple définit la propriété System.Threading.Thread.CurrentThread.CurrentCulture sur da-DK et appelle à nouveau la méthode Array.Sort. Notez la façon dont l'utilisation des conventions de tri définies pour la culture danoise (Danemark) aboutit à un ordre de tri différent de celui obtenu pour la culture en-US.

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

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

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

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

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

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

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

Si votre objectif principal de la comparaison de chaînes consiste à déterminer si elles sont égales, vous devez appeler la String.Equals (méthode). En règle générale, vous devez utiliser Equals pour effectuer une comparaison ordinale. Le String.Compare méthode est conçue essentiellement pour trier les chaînes.

Chaîne des méthodes de recherche, telles que String.StartsWith et String.IndexOf, vous pouvez également exécuter des comparaisons de chaînes dépendantes de la culture ou ordinales. L’exemple suivant illustre les différences entre les comparaisons ordinales et dépendantes de la culture à l’aide du IndexOf (méthode). Une recherche dépendante de la culture dans laquelle la culture actuelle est anglais (États-Unis) considère que la sous-chaîne « oe » pour faire correspondre le digramme soudé « section ». Un trait d’union (U + 00AD) étant un caractère de largeur nulle, la recherche traite le trait d’union comme équivalent à Empty et trouve une correspondance au début de la chaîne. Une recherche ordinale, quant à eux, ne trouve pas de correspondance dans les deux 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

Chaîne des méthodes de recherche, telles que String.StartsWith et String.IndexOf, vous pouvez également exécuter dépendante de la culture ou des comparaisons de chaînes ordinales pour déterminer si un caractère ou une sous-chaîne est trouvé dans une chaîne spécifiée.

Les méthodes de recherche dans les String classe rechercher un caractère individuel, tel que leIndexOf méthode ou un jeu de caractères, tels que le IndexOfAny (méthode), tous effectuent une recherche ordinale. Pour effectuer une recherche dépendante de la culture d’un caractère, vous devez appeler un CompareInfo méthode telle que CompareInfo.IndexOf(String, Char) ou CompareInfo.LastIndexOf(String, Char). Notez que les résultats de recherche d’un caractère à l’aide de la comparaison ordinale et dépendante de la culture peuvent être très différentes. Par exemple, une recherche d’un caractère Unicode précomposé telles que le digramme soudé « Æ » (U + 00 C 6) peut correspondre à toute occurrence de ses composants dans l’ordre approprié, tel que « AE » (U + 041U + 0045), en fonction de la culture. L’exemple suivant illustre la différence entre la String.IndexOf(Char) et CompareInfo.IndexOf(String, Char) méthodes lorsque vous recherchez un caractère individuel. Le digramme soudé « æ » (U + 00E6) se trouve dans la chaîne « aérien » lorsque vous utilisez les conventions de la culture en-US, mais ne pas lorsque vous utilisez les conventions de la culture da-DK ou lorsque vous effectuez une comparaison ordinale.

using System;
using System.Globalization;

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

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

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

En revanche, String les méthodes de recherche de chaîne plutôt qu’un caractère effectuer une recherche dépendante de la culture si les options de recherche ne sont pas explicitement spécifiées par un paramètre de type de la classe StringComparison. La seule exception est Contains, qui effectue une recherche ordinale.

Utilisez la String.Compare méthode pour déterminer la relation entre deux chaînes dans l’ordre de tri. En règle générale, il s’agit d’une opération dépendante de la culture. En revanche, appelez le String.Equals méthode pour tester l’égalité. Le test d’égalité compare habituellement les entrées d’utilisateur avec une chaîne connue, comme un nom d’utilisateur valide, un mot de passe ou un chemin d’accès de système de fichiers, il est généralement une opération ordinale.

System_CAPS_warningAvertissement

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

L’exemple suivant illustre le risque d’effectuer une comparaison dépendante de la culture pour l’égalité lorsqu’un nombre ordinal une doit être utilisée à la place. Dans ce cas, l’objectif du code est d’interdire l’accès au système de fichiers à partir de l’URL qui commencent par « FILE:// » ou « file:// » en effectuant une comparaison respectant 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 turc (Turquie) sur une URL qui commence par « file:// », la comparaison d’égalité échoue, car le turc équivalent en majuscule de « i » minuscule est « » au lieu de « I ». Par conséquent, les accès au système de fichiers est autorisée par inadvertance. En revanche, si une comparaison ordinale est effectuée, la comparaison d’égalité réussit et 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.

Certains caractères Unicode ont plusieurs représentations. Par exemple, un des points de code suivant peut représenter la lettre « ắ » :

  • U + 1EAF

  • U + 0103 U + 0301

  • U + 0061 U + 0306 U + 0301

Plusieurs représentations pour un seul caractère compliquent 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 qui retourne une représentation binaire d’un caractère Unicode pour toutes ses représentations binaires équivalentes. La normalisation peut utiliser plusieurs algorithmes, appelés formulaires de normalisation, qui suivent des règles différentes. Le .NET Framework prend en charge les formulaires de normalisation Unicode C, D, KC et KD. Lorsque les chaînes ont été normalisées selon 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 correspondant Char objets dans chaque chaîne. LaString classe inclut un nombre de méthodes qui peuvent effectuer une comparaison ordinale, notamment les suivantes :

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

L’exemple simple suivant illustre la normalisation des chaînes. 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 que chaque chaîne diffère des deux autres chaînes. Il convertit ensuite chaque chaîne pour les formulaires de normalisation pris en charge et effectue une comparaison ordinale de chaque chaîne de nouveau dans un formulaire 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 que Unicode Standard Annex #15: Unicode Normalization Forms et Normalization FAQ sur le site Web unicode.org.

Le String classe fournit des membres pour comparer des chaînes, les tests d’égalité de chaînes, recherche de caractères ou des sous-chaînes dans une chaîne, la modification d’une chaîne, extraire des sous-chaînes d’une chaîne, la combinaison de chaînes de mise en forme de valeurs, copie d’une chaîne et normalisation d’une chaîne.

Vous pouvez comparer des chaînes pour déterminer leur position relative dans l’ordre de tri en utilisant le Stringméthodes :

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

  • CompareOrdinalRetourne un entier qui indique la relation entre une chaîne et une deuxième chaîne basée sur une comparaison de leurs points de code.

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

Vous appelez le Equals méthode pour déterminer si deux chaînes sont égales. L’instance Equals(String, String, StringComparison) et statiques Equals(String, StringComparison) surcharges vous permettent de spécifier si la comparaison est dépendante de la culture ou ordinale, et si la casse est considérée comme ou ignorée. La plupart des tests d’égalité sont ordinales et les comparaisons d’égalité qui déterminent l’accès à une ressource système (par exemple, un objet de système de fichiers) doivent toujours être un nombre ordinales.

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

  • Les méthodes qui retournent un Boolean valeur pour indiquer si une sous-chaîne particulière est présente dans une instance de chaîne. Celles-ci incluent la Contains, EndsWith, et StartsWith méthodes.

  • Méthodes qui indiquent la position de départ d’une sous-chaîne dans une instance de chaîne. Celles-ci incluent la IndexOf, IndexOfAny, LastIndexOf, et LastIndexOfAny méthodes.

System_CAPS_warningAvertissement

Si vous souhaitez rechercher une chaîne pour un modèle particulier plutôt que d’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.

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

  • InsertInsère une chaîne dans la zone actuelle String instance.

  • PadLeftInsère une ou plusieurs occurrences d’un caractère spécifié au début d’une chaîne.

  • PadRightInsère une ou plusieurs occurrences d’un caractère spécifié au début d’une chaîne.

  • RemoveSupprime une sous-chaîne actuel String instance.

  • Replaceremplace une sous-chaîne par une autre sous-chaîne en cours String instance.

  • ToLoweret ToLowerInvariant convertit tous les caractères dans une chaîne en minuscules.

  • ToUpperet ToUpperInvariant convertit tous les caractères dans une chaîne en majuscules.

  • TrimSupprime toutes les occurrences d’un caractère de début et à la fin d’une chaîne.

  • TrimEndSupprime toutes les occurrences d’un caractère de la fin d’une chaîne.

  • TrimStartSupprime toutes les occurrences d’un caractère de début d’une chaîne.

System_CAPS_importantImportant

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

Le String.Split méthode divise une chaîne unique en plusieurs chaînes. Les surcharges de la méthode permettent de spécifier plusieurs délimiteurs, pour déterminer le nombre maximal 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 inclus dans les chaînes retournées.

Les éléments suivants String méthodes peuvent être utilisées pour la concaténation de chaîne :

  • Concatassocie un ou plusieurs sous-chaînes dans une chaîne unique.

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

Le String.Format méthode utilise la fonctionnalité de mise en forme composite pour remplacer un ou plusieurs des espaces réservés dans une chaîne avec la représentation sous forme de chaîne de l’objet ou valeur. Le Format méthode 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 d’heure dans une chaîne.

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

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

  • À droite ou à gauche une sous-chaîne dans un champ au sein d’une chaîne plus grande.

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

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

  • CloneRetourne une référence à un fichier String objet.

  • CopyCrée une copie d’une chaîne existante.

  • CopyTocopie une partie d’une chaîne dans un tableau de caractères.

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

Pour plus d’informations et obtenir un exemple, consultez la Normalisation section plus haut dans cette rubrique.

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 1.1
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Silverlight
Disponible depuis 2.0
Silverlight pour Windows Phone
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1

Ce type est thread-safe.

Retour au début
Afficher: