String Classe
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
Représente le texte en tant que séquence d’unités de code UTF-16.
public ref class System::String sealed : IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>public ref class System::String sealed : ICloneable, IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>public ref class System::String sealed : ICloneable, IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, IParsable<System::String ^>, ISpanParsable<System::String ^>, System::Collections::Generic::IEnumerable<char>public ref class System::String sealed : ICloneable, IComparable, IConvertible, System::Collections::IEnumerablepublic ref class System::String sealed : IComparable, IComparable<System::String ^>, IEquatable<System::String ^>, System::Collections::IEnumerablepublic ref class System::String sealed : IComparable, IComparable<System::String ^>, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>public sealed class String : IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, IParsable<string>, ISpanParsable<string>, System.Collections.Generic.IEnumerable<char>[System.Serializable]
public sealed class String : ICloneable, IComparable, IConvertible, System.Collections.IEnumerable[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>public sealed class String : IComparable, IComparable<string>, IEquatable<string>, System.Collections.IEnumerablepublic sealed class String : IComparable, IComparable<string>, IEquatable<string>, System.Collections.Generic.IEnumerable<char>type string = class
interface seq<char>
interface IEnumerable
interface IComparable
interface IComparable<string>
interface IConvertible
interface IEquatable<string>type string = class
interface seq<char>
interface IEnumerable
interface ICloneable
interface IComparable
interface IComparable<string>
interface IConvertible
interface IEquatable<string>type string = class
interface seq<char>
interface IEnumerable
interface ICloneable
interface IComparable
interface IComparable<string>
interface IConvertible
interface IEquatable<string>
interface IParsable<string>
interface ISpanParsable<string>type string = class
interface seq<char>
interface IEnumerable
interface IComparable
interface IComparable<string>
interface IConvertible
interface IEquatable<string>
interface ICloneable[<System.Serializable>]
type string = class
interface IComparable
interface ICloneable
interface IConvertible
interface IEnumerable[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type string = class
interface IComparable
interface ICloneable
interface IConvertible
interface IComparable<string>
interface seq<char>
interface IEnumerable
interface IEquatable<string>[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type string = class
interface IComparable
interface ICloneable
interface IConvertible
interface IEnumerable
interface IComparable<string>
interface seq<char>
interface IEquatable<string>type string = class
interface IEnumerable
interface IComparable
interface IComparable<string>
interface IEquatable<string>type string = class
interface IComparable
interface IComparable<string>
interface IEquatable<string>
interface seq<char>
interface IEnumerablePublic NotInheritable Class String
Implements IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String)Public NotInheritable Class String
Implements ICloneable, IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String)Public NotInheritable Class String
Implements ICloneable, IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String), IParsable(Of String), ISpanParsable(Of String)Public NotInheritable Class String
Implements ICloneable, IComparable, IConvertible, IEnumerablePublic NotInheritable Class String
Implements IComparable, IComparable(Of String), IEnumerable, IEquatable(Of String)Public NotInheritable Class String
Implements IComparable, IComparable(Of String), IEnumerable(Of Char), IEquatable(Of String)- Héritage
-
String
- Attributs
- Implémente
Remarques
Une chaîne est une collection séquentielle de caractères qui est utilisée pour représenter du texte. Un String objet est une collection séquentielle d’objets System.Char qui représentent une chaîne ; un System.Char objet correspond à une unité de code UTF-16. La valeur de l’objet String est le contenu de la collection séquentielle d’objets System.Char , et cette valeur est immuable (autrement dit, elle est en lecture seule). Pour plus d’informations sur l’immuabilité des chaînes, consultez la section Immuabilité et la classe StringBuilder . La taille maximale d’un String objet en mémoire est de 2 Go, soit environ 1 milliard de caractères.
Pour plus d’informations sur Unicode, UTF-16, les unités de code, les points de code et les types etRune, consultez Présentation de l’encodageChar de caractères dans .NET.
Dans cette section :
Instancier un objet String
Objets Char et caractères Unicode
Chaînes et Standard Unicode
Chaînes et caractères null incorporés
Chaînes et index
Chaînes Null et chaînes vides
Immuabilité et classe StringBuilder
Opérations ordinales et sensibles à la culture
Normalisation
Opérations de chaîne par catégorie
Instancier un objet String
Vous pouvez instancier un String objet des manières suivantes :
En affectant un littéral de chaîne à une String variable. Il s’agit de la méthode la plus couramment utilisée pour créer une chaîne. L’exemple suivant utilise l’affectation pour créer plusieurs chaînes. Notez qu’en C# et F#, étant donné que la barre oblique inverse (\) est un caractère d’échappement, les barres obliques inverses littérales d’une chaîne doivent être placées dans une séquence d’échappement ou la chaîne entière doit être @-quoted.
using namespace System; void main() { String^ string1 = "This is a string created by assignment."; Console::WriteLine(string1); String^ string2a = "The path is C:\\PublicDocuments\\Report1.doc"; Console::WriteLine(string2a); } // The example displays the following output: // This is a string created by assignment. // The path is C:\PublicDocuments\Report1.docstring 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.doclet string1 = "This is a string created by assignment." printfn "%s" string1 let string2a = "The path is C:\\PublicDocuments\\Report1.doc" printfn "%s" string2a let string2b = @"The path is C:\PublicDocuments\Report1.doc" printfn "%s" 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.docDim string1 As String = "This is a string created by assignment." Console.WriteLine(string1) Dim string2 As String = "The path is C:\PublicDocuments\Report1.doc" Console.WriteLine(string2) ' The example displays the following output: ' This is a string created by assignment. ' The path is C:\PublicDocuments\Report1.docEn appelant un String constructeur de classe. L’exemple suivant instancie des chaînes en appelant plusieurs constructeurs de classes. 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 String les constructeurs, consultez le résumé du String constructeur.
using namespace System; void main() { wchar_t chars[5] = L"word"; char bytes[6] = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 }; // Create a string from a character array. String^ string1 = gcnew String(chars); Console::WriteLine(string1); // Create a string that consists of a character repeated 20 times. String^ string2 = gcnew String('c', 20); Console::WriteLine(string2); String^ stringFromBytes = nullptr; String^ stringFromChars = nullptr; char * pbytes = &bytes[0]; // Create a string from a pointer to a signed byte array. stringFromBytes = gcnew String(pbytes); wchar_t* pchars = &chars[0]; // Create a string from a pointer to a character array. stringFromChars = gcnew String(pchars); Console::WriteLine(stringFromBytes); Console::WriteLine(stringFromChars); Console::ReadLine(); } // The example displays the following output: // word // cccccccccccccccccccc // ABCDE // wordchar[] 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 // wordlet chars = [| 'w'; 'o'; 'r'; 'd' |] let bytes = [| 0x41y; 0x42y; 0x43y; 0x44y; 0x45y; 0x00y |] // Create a string from a character array. let string1 = String chars printfn "%s" string1 // Create a string that consists of a character repeated 20 times. let string2 = String('c', 20) printfn "%s" string2 let stringFromBytes = // Create a string from a pointer to a signed byte array. use pbytes = fixed bytes String pbytes let stringFromChars = // Create a string from a pointer to a character array. use pchars = fixed chars String pchars printfn $"{stringFromBytes}" printfn $"{stringFromChars}" // The example displays the following output: // word // cccccccccccccccccccc // ABCDE // wordDim chars() As Char = { "w"c, "o"c, "r"c, "d"c } ' Create a string from a character array. Dim string1 As New String(chars) Console.WriteLine(string1) ' Create a string that consists of a character repeated 20 times. Dim string2 As New String("c"c, 20) Console.WriteLine(string2) ' The example displays the following output: ' word ' ccccccccccccccccccccEn utilisant l’opérateur de concaténation de chaîne (+ en C# et F#, et & ou + en Visual Basic) pour créer une chaîne unique à partir de n’importe quelle combinaison d’instances et de littéraux de String 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.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.let string1 = "Today is " + DateTime.Now.ToString("D") + "." printfn $"{string1}" let string2 = "This is one sentence. " + "This is a second. " let string2 = string2 + "This is a third sentence." printfn $"{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.Dim string1 As String = "Today is " + Date.Now.ToString("D") + "." Console.WriteLine(string1) Dim string2 As String = "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 récupérant 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);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: sentencelet sentence = "This sentence has five words." // Extract the second word. let startPosition = sentence.IndexOf " " + 1 let word2 = sentence.Substring(startPosition, sentence.IndexOf(" ", startPosition) - startPosition) printfn $"Second word: {word2}" // The example displays the following output: // Second word: sentenceDim sentence As String = "This sentence has five words." ' Extract the second word. Dim startPosition As Integer = sentence.IndexOf(" ") + 1 Dim word2 As String = sentence.Substring(startPosition, sentence.IndexOf(" ", startPosition) - startPosition) Console.WriteLine("Second word: " + word2) ' The example displays the following output: ' Second word: sentenceEn appelant une méthode de mise en forme pour convertir une valeur ou un objet en sa représentation sous forme de chaîne. L’exemple suivant utilise la fonctionnalité de mise en forme composite pour incorporer la représentation sous forme de chaîne de deux objets dans une chaîne.
DateTime^ dateAndTime = gcnew 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.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.let dateAndTime = DateTime(2011, 7, 6, 7, 32, 0) let temperature = 68.3 String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.", dateAndTime, temperature) |> printfn "%s" // The example displays the following output: // At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.Dim dateAndTime As DateTime = #07/06/2011 7:32:00AM# Dim temperature As Double = 68.3 Dim result As String = String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.", dateAndTime, temperature) Console.WriteLine(result) ' The example displays the following output: ' At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.
Objets Char et caractères Unicode
Chaque caractère d’une chaîne est défini par une valeur scalaire Unicode, également appelée point de code Unicode ou valeur ordinale (numérique) du caractère Unicode. Chaque point de code est encodé à l’aide de l’encodage UTF-16, et la valeur numérique de chaque élément de l’encodage est représentée par un Char objet .
Notes
Notez que, étant donné qu’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 a un substitut faible sans substitut élevé correspondant. Bien que certaines méthodes, telles que les méthodes d’encodage et de décodage d’objets dans l’espace System.Text de noms, puissent effectuer des vérifications pour s’assurer que les chaînes sont bien formées, String les membres de classe ne garantissent pas qu’une chaîne est bien formée.
Un objet unique Char représente généralement un point de code unique; autrement dit, la valeur numérique du 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 objets). La norme Unicode définit deux types de caractères qui correspondent à plusieurs Char objets : les graphèmes et les points de code supplémentaires Unicode qui correspondent aux caractères des plans supplémentaires Unicode.
Un graphème est représenté par un caractère de base suivi d’un ou plusieurs caractères combinés. Par exemple, le caractère ä est représenté par un Char objet dont le point de code est U+0061 suivi d’un Char objet dont le point de code est U+0308. Ce caractère peut également être défini par un objet unique Char dont le point de code est U+00E4. Comme le montre l’exemple suivant, une comparaison d’égalité sensible à la culture indique que ces deux représentations sont égales, bien qu’une comparaison ordinale ordinaire ne le fasse pas. Toutefois, si les deux chaînes sont normalisées, une comparaison ordinale indique également qu’elles sont égales. (Pour plus d’informations sur la normalisation des chaînes, consultez la section Normalisation .)
using namespace System; using namespace System::Globalization; using namespace System::IO; void main() { StreamWriter^ sw = gcnew StreamWriter(".\\graphemes.txt"); String^ grapheme = L"a" + L"\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): Trueusing 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): Trueopen System open System.IO do use sw = new StreamWriter(@".\graphemes.txt") let grapheme = "\u0061\u0308" sw.WriteLine grapheme let 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)) // The example produces the following output: // ä // ä // ä = ä (Culture-sensitive): True // ä = ä (Ordinal): False // ä = ä (Normalized Ordinal): TrueImports System.Globalization Imports System.IO Module Example Public Sub Main() Dim sw As New StreamWriter(".\graphemes.txt") Dim grapheme As String = ChrW(&H0061) + ChrW(&h0308) sw.WriteLine(grapheme) Dim singleChar As String = ChrW(&h00e4) 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() End Sub End Module ' The example produces the following output: ' ä ' ä ' ä = ä (Culture-sensitive): True ' ä = ä (Ordinal): False ' ä = ä (Normalized Ordinal): TrueUn point de code supplémentaire Unicode (paire de substitution) est représenté par un objet dont le Char point de code est un substitut élevé suivi d’un Char objet dont le point de code est un substitut faible. Les unités de code des substitutions élevées vont de U+D800 à U+DBFF. Les unités de code des substituts bas vont de U+DC00 à U+DFFF. Les paires de substitution sont utilisées pour représenter des caractères dans les 16 plans supplémentaires Unicode. L’exemple suivant crée un caractère de substitution et le transmet à la Char.IsSurrogatePair(Char, Char) méthode pour déterminer s’il s’agit d’une paire de substitution.
using namespace System; void main() { String^ surrogate = L"\xD800\xDC03" ; for (int ctr = 0; ctr < surrogate->Length; ctr++) Console::Write("U+{0:X4} ", Convert::ToUInt16(surrogate[ctr])); Console::WriteLine(); Console::WriteLine(" Is Surrogate Pair: {0}", Char::IsSurrogatePair(surrogate[0], surrogate[1])); Console::ReadLine(); } // The example displays the following output: // U+D800 U+DC03 // Is Surrogate Pair: Truestring surrogate = "\uD800\uDC03"; for (int ctr = 0; ctr < surrogate.Length; ctr++) Console.Write($"U+{(ushort)surrogate[ctr]:X2} "); 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: Trueopen System let surrogate = "\uD800\uDC03" for i = 0 to surrogate.Length - 1 do printf $"U+{uint16 surrogate[i]:X2} " printfn $"\n Is Surrogate Pair: {Char.IsSurrogatePair(surrogate[0], surrogate[1])}" // The example displays the following output: // U+D800 U+DC03 // Is Surrogate Pair: TrueModule Example Public Sub Main() Dim surrogate As String = ChrW(&hD800) + ChrW(&hDC03) For ctr As Integer = 0 To surrogate.Length - 1 Console.Write("U+{0:X2} ", Convert.ToUInt16(surrogate(ctr))) Next Console.WriteLine() Console.WriteLine(" Is Surrogate Pair: {0}", Char.IsSurrogatePair(surrogate(0), surrogate(1))) End Sub End Module ' The example displays the following output: ' U+D800 U+DC03 ' Is Surrogate Pair: True
Chaînes et norme Unicode
Les caractères d’une chaîne sont représentés par des unités de code encodées en UTF-16, qui correspondent à des 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 .NET par l’énumération UnicodeCategory . La catégorie d’un caractère ou d’une paire de substitution peut être déterminée en appelant la CharUnicodeInfo.GetUnicodeCategory méthode .
.NET gère sa propre table de caractères et ses catégories correspondantes, ce qui garantit qu’une version spécifique d’une implémentation de .NET s’exécutant sur différentes plateformes retourne des informations de catégorie de caractère identiques. Sur toutes les versions de .NET et sur toutes les plateformes de système d’exploitation, les informations sur les catégories de caractères sont fournies par la base de données de caractères Unicode.
Le tableau suivant liste les versions de .NET et les versions de la norme Unicode Standard sur lesquelles reposent leurs catégories de caractère.
| Version de .NET | Version de la norme Unicode Standard |
|---|---|
| .NET Framework 1.1 | The Unicode Standard, version 4.0.0 |
| .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 et versions ultérieures | The Unicode Standard, version 8.0.0 |
| .NET Core 2.1 | The Unicode Standard, version 8.0.0 |
| .NET Core 3.1 | Norme Unicode, version 11.0.0 |
| .NET 5 | Norme Unicode, version 13.0.0 |
En outre, .NET prend en charge la comparaison et le tri de chaînes en fonction de la norme Unicode. .NET Framework 4 et les versions antérieures conservent leur propre table de données de chaîne. Cela vaut également pour les versions de .NET Framework commençant par .NET Framework 4.5 s’exécutant sur Windows 7. À compter de .NET Framework 4.5 exécuté sur Windows 8 et versions ultérieures du système d’exploitation Windows, le runtime délègue les opérations de comparaison et de tri de chaînes au système d’exploitation. Sur .NET Core et .NET 5+, les informations de comparaison et de tri des chaînes sont fournies par les composants internationaux pour les bibliothèques Unicode (sauf sur les versions de Windows antérieures à Windows 10 mise à jour de mai 2019). Le tableau suivant répertorie les versions de .NET et les versions de la norme Unicode sur lesquelles la comparaison et le tri de caractères sont basés.
| Version de .NET | Version de la norme Unicode Standard |
|---|---|
| .NET Framework 1.1 | The Unicode Standard, version 4.0.0 |
| .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 et ultérieur sur Windows 7 | The Unicode Standard, version 5.0.0 |
| .NET Framework 4.5 et versions ultérieures sur les systèmes d’exploitation Windows 8 et ultérieur | The Unicode Standard, version 6.3.0 |
| .NET Core et .NET 5+ | En fonction de la version de la norme Unicode prise en charge par le système d’exploitation sous-jacent. |
Chaînes et caractères Null incorporés
Dans .NET, un String objet peut inclure des caractères Null incorporés, qui comptent comme une partie de la longueur de la chaîne. Toutefois, dans certains langages tels que C et C++, un caractère null indique la fin d’une chaîne ; il n’est pas considéré comme une partie de la chaîne et n’est pas compté comme faisant partie de la longueur de la chaîne. Cela signifie que les hypothèses courantes suivantes que les programmeurs ou bibliothèques C et C++ écrits en C ou C++ peuvent faire sur les chaînes ne sont pas nécessairement valides lorsqu’elles sont appliquées à des String objets :
La valeur retournée par les
strlenfonctions ouwcslenn’est pas nécessairement égale à String.Length.La chaîne créée par les
strcpy_sfonctions ou n’estwcscpy_spas nécessairement identique à la chaîne créée par la String.Copy méthode .
Vous devez vous assurer que le code C et C++ natif qui instancie des String objets, et le code qui est passé String par le biais d’un appel de plateforme, ne supposent pas qu’un caractère Null incorporé marque la fin de la chaîne.
Les caractères Null incorporés dans une chaîne sont également traités différemment lorsqu’une chaîne est triée (ou comparée) et lorsqu’une chaîne est recherchée. Les caractères Null sont ignorés lors de l’exécution de comparaisons sensibles à la culture entre deux chaînes, y compris les comparaisons utilisant la culture invariante. Elles ne sont prises en compte que pour les comparaisons ordinales ou ordinales qui ne respectent pas la casse. En revanche, les caractères Null incorporés sont toujours pris en compte lors de la recherche d’une chaîne avec des méthodes telles que Contains, StartsWithet IndexOf.
Chaînes et index
Un index est la position d’un Char objet (et non 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 de la chaîne, qui est la position d’index zéro. Un certain nombre de méthodes de recherche, telles que IndexOf et LastIndexOf, retournent l’index d’un caractère ou d’une sous-chaîne dans la chaîne instance.
La Chars[] propriété vous permet d’accéder à des objets individuels Char en fonction de 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# et F#), vous pouvez accéder aux objets individuels Char dans une chaîne à l’aide d’un code tel que le suivant. Ce code recherche des espaces blancs ou des caractères de ponctuation dans une chaîne pour déterminer le nombre de mots que contient la chaîne.
using namespace System;
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.
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.
let s1 = "This string consists of a single short sentence."
let mutable nWords = 0
for i = 0 to s1.Length - 1 do
if Char.IsPunctuation s1[i] || Char.IsWhiteSpace s1[i] then
nWords <- nWords + 1
printfn $"The sentence\n {s1}\nhas {nWords} words."
// The example displays the following output:
// The sentence
// This string consists of a single short sentence.
// has 8 words.
Module Example
Public Sub Main()
Dim s1 As String = "This string consists of a single short sentence."
Dim nWords As Integer = 0
s1 = s1.Trim()
For ctr As Integer = 0 To s1.Length - 1
If Char.IsPunctuation(s1(ctr)) Or Char.IsWhiteSpace(s1(ctr))
nWords += 1
End If
Next
Console.WriteLine("The sentence{2} {0}{2}has {1} words.",
s1, nWords, vbCrLf)
End Sub
End Module
' The example displays the following output:
' The sentence
' This string consists of a single short sentence.
' has 8 words.
Étant donné que la String classe implémente l’interface IEnumerable , vous pouvez également effectuer une itération au sein des objets d’une chaîne à l’aide Char d’une foreach construction, comme le montre l’exemple suivant.
using namespace System;
void main()
{
String^ s1 = "This string consists of a single short sentence.";
int nWords = 0;
s1 = s1->Trim();
for each (Char ch in s1)
{
if (Char::IsPunctuation(ch) | Char::IsWhiteSpace(ch))
nWords++;
}
Console::WriteLine("The sentence\n {0}\nhas {1} words.",
s1, nWords);
Console::ReadLine();
}
// The example displays the following output:
// The sentence
// This string consists of a single short sentence.
// has 8 words.
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.
let s1 = "This string consists of a single short sentence."
let mutable nWords = 0
for ch in s1 do
if Char.IsPunctuation ch || Char.IsWhiteSpace ch then
nWords <- nWords + 1
printfn $"The sentence\n {s1}\nhas {nWords} words."
// The example displays the following output:
// The sentence
// This string consists of a single short sentence.
// has 8 words.
Module Example
Public Sub Main()
Dim s1 As String = "This string consists of a single short sentence."
Dim nWords As Integer = 0
s1 = s1.Trim()
For Each ch In s1
If Char.IsPunctuation(ch) Or Char.IsWhiteSpace(ch) Then
nWords += 1
End If
Next
Console.WriteLine("The sentence{2} {0}{2}has {1} words.",
s1, nWords, vbCrLf)
End Sub
End Module
' The example displays the following output:
' The sentence
' This string consists of a single short sentence.
' has 8 words.
Les valeurs d’index Char consécutives peuvent ne pas correspondre à des caractères Unicode consécutifs, car un caractère Unicode peut être encodé comme plusieurs objets. En particulier, une chaîne peut contenir des unités de texte à plusieurs caractères formées par un caractère de base suivi d’un ou de plusieurs caractères de combinaison ou de paires de substitution. Pour utiliser des caractères Unicode au lieu d’objets Char , utilisez les System.Globalization.StringInfo classes et TextElementEnumerator , ou la String.EnumerateRunes méthode et le Rune struct. L’exemple suivant illustre la différence entre le code qui fonctionne avec Char des objets et le code qui fonctionne avec des caractères Unicode. Il compare le nombre de caractères ou d’éléments de texte dans chaque mot d’une phrase. La chaîne comprend deux séquences d’un caractère de base suivi d’un caractère de combinaison.
using namespace System;
using namespace System::Collections::Generic;
using namespace System::Globalization;
void main()
{
// First sentence of The Mystery of the Yellow Room, by Leroux.
String^ opening = L"Ce n'est pas sans une certaine émotion que "+
L"je commence à raconter ici les aventures " +
L"extraordinaires de Joseph Rouletabille.";
// Character counters.
int nChars = 0;
// Objects to store word count.
List<int>^ chars = gcnew List<int>();
List<int>^ elements = gcnew List<int>();
for each (Char ch in opening) {
// Skip the ' character.
if (ch == '\x0027') 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 == "\x0027") 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]);
Console::ReadLine();
}
// 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
// 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++;
}
}
System.Globalization.TextElementEnumerator te =
System.Globalization.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
open System
open System.Globalization
// First sentence of The Mystery of the Yellow Room, by Leroux.
let opening = "Ce n'est pas sans une certaine émotion que je commence à raconter ici les aventures extraordinaires de Joseph Rouletabille."
// Character counters.
let mutable nChars = 0
// Objects to store word count.
let chars = ResizeArray<int>()
let elements = ResizeArray<int>()
for ch in opening do
// Skip the ' character.
if ch <> '\u0027' then
if Char.IsWhiteSpace ch || Char.IsPunctuation ch then
chars.Add nChars
nChars <- 0
else
nChars <- nChars + 1
let te = StringInfo.GetTextElementEnumerator opening
while te.MoveNext() do
let s = te.GetTextElement()
// Skip the ' character.
if s <> "\u0027" then
if String.IsNullOrEmpty(s.Trim()) || (s.Length = 1 && Char.IsPunctuation(Convert.ToChar s)) then
elements.Add nChars
nChars <- 0
else
nChars <- nChars + 1
// Display character counts.
printfn "%6s %20s %20s" "Word #" "Char Objects " "Characters"
for i = 0 to chars.Count - 1 do
printfn "%6d %20d %20d" i chars[i] elements[i]
// 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
Imports System.Collections.Generic
Imports System.Globalization
Module Example
Public Sub Main()
' First sentence of The Mystery of the Yellow Room, by Leroux.
Dim opening As String = "Ce n'est pas sans une certaine émotion que "+
"je commence à raconter ici les aventures " +
"extraordinaires de Joseph Rouletabille."
' Character counters.
Dim nChars As Integer = 0
' Objects to store word count.
Dim chars As New List(Of Integer)()
Dim elements As New List(Of Integer)()
For Each ch In opening
' Skip the ' character.
If ch = ChrW(&h0027) Then Continue For
If Char.IsWhiteSpace(ch) Or Char.IsPunctuation(ch) Then
chars.Add(nChars)
nChars = 0
Else
nChars += 1
End If
Next
Dim te As TextElementEnumerator = StringInfo.GetTextElementEnumerator(opening)
Do While te.MoveNext()
Dim s As String = te.GetTextElement()
' Skip the ' character.
If s = ChrW(&h0027) Then Continue Do
If String.IsNullOrEmpty(s.Trim()) Or (s.Length = 1 AndAlso Char.IsPunctuation(Convert.ToChar(s)))
elements.Add(nChars)
nChars = 0
Else
nChars += 1
End If
Loop
' Display character counts.
Console.WriteLine("{0,6} {1,20} {2,20}",
"Word #", "Char Objects", "Characters")
For ctr As Integer = 0 To chars.Count - 1
Console.WriteLine("{0,6} {1,20} {2,20}",
ctr, chars(ctr), elements(ctr))
Next
End Sub
End Module
' 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 utilise des éléments de texte à l’aide de la StringInfo.GetTextElementEnumerator méthode et de la TextElementEnumerator classe pour énumérer tous les éléments de texte d’une chaîne. Vous pouvez également récupérer un tableau qui contient l’index de départ de chaque élément de texte en appelant la StringInfo.ParseCombiningCharacters méthode .
Pour plus d’informations sur l’utilisation d’unités de texte plutôt que de valeurs individuelles Char , consultez Présentation de l’encodage de caractères dans .NET.
Chaînes Null et chaînes vides
Une chaîne qui a été déclarée mais qui n’a pas reçu de 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, le passage d’une chaîne null ou d’une chaîne vide en tant qu’argument dans un appel de méthode lève une exception. Par exemple, le passage d’une chaîne Null à la Int32.Parse méthode lève un ArgumentNullException, et le passage d’une chaîne vide lève un 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 une IFormattable implémentation pour une classe, vous souhaitez mettre en correspondance une chaîne null et une chaîne vide avec le spécificateur de format général (« G »).
La 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égale ou égale à String.Empty. Cette méthode élimine la nécessité d’utiliser du code tel que le suivant :if (str == nullptr || str->Equals(String::Empty))if (str == null || str.Equals(String.Empty))if str = null || str.Equals String.Empty thenIf str Is Nothing OrElse str.Equals(String.Empty) ThenIsNullOrWhiteSpace, qui indique si une chaîne est
null, est égale String.Emptyà ou se compose exclusivement de caractères d’espace blanc. Cette méthode élimine la nécessité d’utiliser du code tel que le suivant :if (str == nullptr || str->Equals(String::Empty) || str->Trim()->Equals(String::Empty))if (str == null || str.Equals(String.Empty) || str.Trim().Equals(String.Empty))if str = null || str.Equals String.Empty || str.Trim().Equals String.Empty thenIf str Is Nothing OrElse str.Equals(String.Empty) OrElse str.Trim().Equals(String.Empty)
L’exemple suivant utilise la IsNullOrEmpty méthode dans l’implémentation IFormattable.ToString d’une classe personnalisée Temperature . La méthode prend en charge les chaînes de format « G », « C », « F » et « K ». Si une chaîne de format vide ou une chaîne de format dont la valeur est null passée à la méthode, sa valeur est remplacée par la chaîne de format « G ».
public:
virtual String^ ToString(String^ format, IFormatProvider^ provider)
{
if (String::IsNullOrEmpty(format)) format = "G";
if (provider == nullptr) provider = CultureInfo::CurrentCulture;
switch (Convert::ToUInt16(format->ToUpperInvariant()))
{
// Return degrees in Celsius.
case 'G':
case 'C':
return temp.ToString("F2", provider) + L"�C";
// Return degrees in Fahrenheit.
case 'F':
return (temp * 9 / 5 + 32).ToString("F2", provider) + L"�F";
// Return degrees in Kelvin.
case 'K':
return (temp + 273.15).ToString();
default:
throw gcnew FormatException(
String::Format("The {0} format string is not supported.",
format));
}
}
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));
}
}
member _.ToString(format: string, provider: IFormatProvider) =
let format =
if String.IsNullOrEmpty format then "G" else format
let provider: IFormatProvider =
if provider = null then CultureInfo.CurrentCulture else provider
match format.ToUpperInvariant() with
// Return degrees in Celsius.
| "G"
| "C" ->
temp.ToString("F2", provider) + "°C"
// Return degrees in Fahrenheit.
| "F" ->
(temp * 9. / 5. + 32.).ToString("F2", provider) + "°F"
// Return degrees in Kelvin.
| "K" ->
(temp + 273.15).ToString()
| _ ->
raise (FormatException(String.Format("The {0} format string is not supported.",format)))
Public Overloads Function ToString(fmt As String, provider As IFormatProvider) As String _
Implements IFormattable.ToString
If String.IsNullOrEmpty(fmt) Then fmt = "G"
If provider Is Nothing Then provider = CultureInfo.CurrentCulture
Select Case fmt.ToUpperInvariant()
' Return degrees in Celsius.
Case "G", "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()
Case Else
Throw New FormatException(
String.Format("The {0} format string is not supported.",
fmt))
End Select
End Function
Immuabilité et classe StringBuilder
Un String objet est appelé immuable (lecture seule), car sa valeur ne peut pas être modifiée une fois qu’il a été créé. Les méthodes qui semblent modifier un String objet retournent en fait un nouvel String objet qui contient la modification.
Étant donné que les chaînes sont immuables, les routines de manipulation de chaînes qui effectuent des ajouts ou des suppressions répétés à ce qui semble être une chaîne unique peuvent entraîner une pénalité importante en matière de 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 0x0001 à 0x052F. Bien que le code semble utiliser la concaténation de chaîne pour ajouter un nouveau caractère à la chaîne existante nommée str, il crée en fait un objet String pour chaque opération de concaténation.
using namespace System;
using namespace System::IO;
using namespace System::Text;
void main()
{
Random^ rnd = gcnew Random();
String^ str = String::Empty;
StreamWriter^ sw = gcnew 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();
}
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 += (char)rnd.Next(1, 0x0530);
if (str.Length % 60 == 0)
str += Environment.NewLine;
}
sw.Write(str);
sw.Close();
}
}
open System
open System.IO
open System.Text
do
let rnd = Random()
let mutable str = String.Empty
use sw = new StreamWriter(@".\StringFile.txt", false, Encoding.Unicode)
for _ = 0 to 1000 do
str <- str + (rnd.Next(1, 0x0530) |> char |> string)
if str.Length % 60 = 0 then
str <- str + Environment.NewLine
sw.Write str
Imports System.IO
Imports System.Text
Module Example
Public Sub Main()
Dim rnd As New Random()
Dim str As String = String.Empty
Dim sw As New StreamWriter(".\StringFile.txt",
False, Encoding.Unicode)
For ctr As Integer = 0 To 1000
str += ChrW(rnd.Next(1, &h0530))
If str.Length Mod 60 = 0 Then str += vbCrLf
Next
sw.Write(str)
sw.Close()
End Sub
End Module
Vous pouvez utiliser la classe à la StringBuilder place de la classe pour les String opérations qui apportent plusieurs modifications à la valeur d’une chaîne. Contrairement aux instances de la String classe, StringBuilder les objets sont mutables ; lorsque vous concaténer, ajouter ou supprimer 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 objet, vous pouvez appeler sa StringBuilder.ToString méthode pour le convertir en chaîne. L’exemple suivant remplace le String utilisé dans l’exemple précédent pour concaténer 1 000 caractères aléatoires dans la plage pour 0x0001 à 0x052F avec un StringBuilder objet .
using namespace System;
using namespace System::IO;
using namespace System::Text;
void main()
{
Random^ rnd = gcnew Random();
StringBuilder^ sb = gcnew StringBuilder();
StreamWriter^ sw = gcnew 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();
}
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((char)rnd.Next(1, 0x0530));
if (sb.Length % 60 == 0)
sb.AppendLine();
}
sw.Write(sb.ToString());
sw.Close();
}
}
open System
open System.IO
open System.Text
do
let rnd = Random()
let sb = StringBuilder()
use sw = new StreamWriter(@".\StringFile.txt", false, Encoding.Unicode)
for _ = 0 to 1000 do
sb.Append(rnd.Next(1, 0x0530) |> char) |> ignore
if sb.Length % 60 = 0 then
sb.AppendLine() |> ignore
sw.Write(string sb)
Imports System.IO
Imports System.Text
Module Example
Public Sub Main()
Dim rnd As New Random()
Dim sb As New StringBuilder()
Dim sw As New StreamWriter(".\StringFile.txt",
False, Encoding.Unicode)
For ctr As Integer = 0 To 1000
sb.Append(ChrW(rnd.Next(1, &h0530)))
If sb.Length Mod 60 = 0 Then sb.AppendLine()
Next
sw.Write(sb.ToString())
sw.Close()
End Sub
End Module
Opérations ordinales et culturelles
Les membres de la String classe effectuent des opérations ordinales ou culturelles (linguistiques) sur un String objet. Une opération ordinale agit sur la valeur numérique de chaque Char objet. Une opération sensible à la culture agit sur la valeur de l’objet String et prend en compte les règles de casse, de tri, de mise en forme et d’analyse propres à la culture. Les opérations sensibles à la culture s’exécutent dans le contexte d’une culture explicitement déclarée ou de la culture actuelle implicite. Les deux types d’opérations peuvent produire des résultats très différents lorsqu’elles sont effectuées sur la même chaîne.
.NET prend également en charge les opérations de chaîne linguistique qui ne respectent pas la culture en utilisant la culture invariante (CultureInfo.InvariantCulture), qui est faiblement basée sur les paramètres de culture de la langue anglaise, indépendamment de la région. Contrairement à d’autres System.Globalization.CultureInfo paramètres, les paramètres de la culture invariante sont garantis pour rester cohérents sur un seul ordinateur, du système au système et entre les versions de .NET. La culture invariante peut être considérée comme une sorte de boîte noire qui garantit la stabilité des comparaisons de chaînes et de l’ordre dans toutes les cultures.
Important
Si votre application prend une décision de sécurité concernant un identificateur symbolique tel qu’un nom de fichier ou un canal nommé, ou des données persistantes telles que les données textuelles dans un fichier XML, l’opération doit utiliser une comparaison ordinale au lieu d’une comparaison sensible à la culture. Cela est dû au fait qu’une comparaison sensible à la culture peut produire des résultats différents en fonction de la culture en vigueur, tandis qu’une comparaison ordinale dépend uniquement de la valeur binaire des caractères comparés.
Important
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 sensible à la culture. En général, vous devez appeler cette surcharge pour que l’intention de votre appel de méthode soit claire. Pour connaître les meilleures pratiques et obtenir des conseils sur l’utilisation d’opérations ordinales et sensibles à la culture sur les chaînes, consultez Meilleures pratiques pour l’utilisation de chaînes.
Les opérations de casse, d’analyse et de mise en forme, de comparaison et de tri, et de test d’égalité peuvent être ordinales ou sensibles à la culture. Les sections suivantes décrivent chaque catégorie d’opération.
Conseil
Vous devez toujours appeler une surcharge de méthode qui rend l’intention de votre appel de méthode claire. Par exemple, au lieu d’appeler la Compare(String, String) méthode pour effectuer une comparaison sensible à la culture de deux chaînes à l’aide des conventions de la culture actuelle, vous devez appeler la Compare(String, String, StringComparison) méthode avec la valeur pour l’argument StringComparison.CurrentCulturecomparisonType . Pour plus d’informations, consultez Bonnes pratiques l’utilisation de chaînes.
Vous pouvez télécharger les tables de pondération de tri, un ensemble de fichiers texte qui contiennent des informations sur les pondérations de caractères utilisées dans les opérations de tri et de comparaison, à partir des liens suivants :
- Windows (.NET Framework et .NET Core) : tri des tables de pondération
- Windows 10 mise à jour de mai 2019 ou ultérieure (.NET 5+) et Linux et macOS (.NET Core et .NET 5+) : Table d’éléments de classement Unicode par défaut
Casse
Les règles de casse déterminent comment modifier la mise en majuscule d’un caractère Unicode ; par exemple, du minuscule au majuscule. Souvent, une opération de casse est effectuée avant une comparaison de chaînes. Par exemple, une chaîne peut être convertie en majuscules afin qu’elle puisse être comparée à une autre chaîne majuscule. Vous pouvez convertir les caractères d’une chaîne en minuscules en appelant la ToLower méthode ou ToLowerInvariant , et vous pouvez les convertir en majuscules en appelant la ToUpper méthode ou ToUpperInvariant . En outre, vous pouvez utiliser la TextInfo.ToTitleCase méthode pour convertir une chaîne en casse de titre.
Notes
.NET Core exécuté sur des systèmes Linux et macOS uniquement : Le comportement de classement pour les cultures C et Posix respecte toujours la casse, car ces cultures n’utilisent pas l’ordre de classement Unicode attendu. Nous vous recommandons d’utiliser une culture autre que C ou Posix pour effectuer des opérations de tri respectant la culture, mais ne respectant pas la casse.
Les opérations de casse peuvent être basées sur les règles de la culture actuelle, d’une culture spécifiée ou de la culture invariante. Étant donné que les mappages de cas peuvent varier en fonction de la culture utilisée, le résultat des opérations de casse peut varier en fonction de la culture. Les différences réelles de casse sont de trois types :
DIFFÉRENCES DANS LE MAPPAGE DE CAS DE LETTRE MAJUSCULE LATINE I (U+0049), LETTRE MINUSCULE LATINE I (U+0069), LETTRE MAJUSCULE LATINE I POINT SUPÉRIEUR (U+0130) ET LETTRE MINUSCULE LATINE POINTILLÉ I (U+0131). Dans les cultures tr-TR (Turc (Turquie)) et az-Latn-AZ (Azerbaïdjan, Latin), et dans les cultures neutres tr, az, et az-Latn, l’équivalent en minuscules de LETTRE MAJUSCULE LATINE I est LETTRE MINUSCULE LETTRE MINUSCULE SANS POINT I, et l’équivalent majuscule de LETTRE MINUSCULE LATINE I EST LETTRE MAJUSCULE LATINE I POINT AU-DESSUS. Dans toutes les autres cultures, y compris la culture invariante, LETTRE MINUSCULE LATINE I et LETTRE MAJUSCULE LATINE I sont des équivalents en minuscules et majuscules.
L’exemple suivant montre comment une comparaison de chaînes conçue pour empêcher l’accès au système de fichiers peut échouer si elle s’appuie sur une comparaison de casses respectant la culture. (Les conventions de casse de la culture invariante auraient dû être 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: Trueopen System open System.Globalization open System.Threading let disallowed = "file" let isAccessAllowed (resource: string) = let cultures = [| CultureInfo.CreateSpecificCulture "en-US" CultureInfo.CreateSpecificCulture "tr-TR" |] let index = resource.IndexOfAny [| '\\'; '/' |] let scheme = if index > 0 then resource.Substring(0, index - 1) else null // Change the current culture and perform the comparison. for culture in cultures do Thread.CurrentThread.CurrentCulture <- culture printfn $"Culture: {CultureInfo.CurrentCulture.DisplayName}" printfn $"{resource}" printfn $"Access allowed: {String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase) |> not}" printfn "" isAccessAllowed @"FILE:\\\c:\users\user001\documents\FinancialInfo.txt" // 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: TrueImports System.Globalization Imports System.Threading Module Example Const disallowed = "file" Public Sub Main() IsAccessAllowed("FILE:\\\c:\users\user001\documents\FinancialInfo.txt") End Sub Private Sub IsAccessAllowed(resource As String) Dim cultures() As CultureInfo = { CultureInfo.CreateSpecificCulture("en-US"), CultureInfo.CreateSpecificCulture("tr-TR") } Dim scheme As String = Nothing Dim index As Integer = resource.IndexOfAny( {"\"c, "/"c }) If index > 0 Then scheme = resource.Substring(0, index - 1) ' Change the current culture and perform the comparison. For Each culture In cultures Thread.CurrentThread.CurrentCulture = culture Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName) Console.WriteLine(resource) Console.WriteLine("Access allowed: {0}", Not String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase)) Console.WriteLine() Next End Sub End Module ' 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: TrueDifférences dans les mappages de cas entre la culture invariante et toutes les autres cultures. Dans ce cas, l’utilisation des règles de casse de la culture invariante pour remplacer un caractère en majuscules ou minuscules retourne le même caractère. Pour toutes les autres cultures, elle retourne un caractère différent. Certains des caractères affectés sont répertoriés dans le tableau suivant.
Caractère S’il est remplacé par Retours SIGNE MICRON (U+00B5) Majuscules LETTRE MAJUSCULE GRECQUE MU (U+-39C) LETTRE MAJUSCULE LATINE I POINT SUPÉRIEUR (U+0130) Minuscules LETTRE MINUSCULE LATINE I (U+0069) LETTRE MINUSCULE LATINE I SANS POINT (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 LETTRE MINUSCULE Z CARON (U+01C5) Minuscules LETTRE MINUSCULE LATINE DZ CARON (U+01C6) COMBINAISON GRECQUE YPOGEGRAMMENI (U+0345) Majuscules LETTRE MAJUSCULE GRECQUE IOTA (U+0399) Différences dans les mappages de cas de paires à deux lettres en majuscules dans la plage de caractères ASCII. Dans la plupart des cultures, une paire à deux lettres en majuscules ou minuscules est égale à deux lettres majuscules ou minuscules. 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 digraphe :
« lJ » et « nJ » dans la culture hr-HR (Croate (Croatie)).
« cH » dans les cultures cs-CZ (Tchèque (République tchèque)) et sk-SK (Slovaque (Slovaquie)).
« aA » dans la culture da-DK (Danemark)).
« cS », « dZ », « dZS », « nY », « sZ », « tY » et « zS » dans la culture hu-HU (Hongrie (Hongrie)).
« cH » et « lL » dans la culture es-ES_tradnl (espagnol (Espagne, tri traditionnel)).
« cH », « gI », « kH », « nG » « nH », « pH », « qU', « tH » et « tR » dans la culture vi-VN (Vietnam)).
Toutefois, il est rare de rencontrer une situation dans laquelle une comparaison de ces paires sensible à la culture crée des problèmes, car ces paires sont rares dans les chaînes fixes ou les identificateurs.
L’exemple suivant illustre certaines des différences entre les règles de casse entre les cultures lors de la conversion de chaînes en majuscules.
using namespace System;
using namespace System::Globalization;
using namespace System::IO;
String^ ShowHexValue(String^ s);
void main()
{
StreamWriter^ sw = gcnew StreamWriter(".\\case.txt");
array<String^>^ words = gcnew array<String^> { L"file", L"sıfır", L"Dženana" };
array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture,
gcnew CultureInfo("en-US"),
gcnew CultureInfo("tr-TR") };
for each (String^ word in words) {
sw->WriteLine("{0}:", word);
for each (CultureInfo^ 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();
}
String^ ShowHexValue(String^ s)
{
String^ retval = nullptr;
for each (Char ch in s) {
array<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
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
open System
open System.Globalization
open System.IO
let showHexValue (s: string) =
let mutable retval = ""
for ch in s do
let bytes = BitConverter.GetBytes ch
retval <- retval + String.Format("{0:X2} {1:X2} ", bytes[1], bytes[0])
retval
do
use sw = new StreamWriter(@".\case.txt")
let words = [| "file"; "sıfır"; "Dženana" |]
let cultures =
[| CultureInfo.InvariantCulture
CultureInfo "en-US"
CultureInfo "tr-TR" |]
for word in words do
sw.WriteLine("{0}:", word)
for culture in cultures do
let name =
if String.IsNullOrEmpty culture.Name then "Invariant" else culture.Name
let upperWord = word.ToUpper culture
sw.WriteLine(" {0,10}: {1,7} {2, 38}", name, upperWord, showHexValue upperWord)
sw.WriteLine()
sw.Close()
// 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
Imports System.Globalization
Imports System.IO
Module Example
Public Sub Main()
Dim sw As New StreamWriter(".\case.txt")
Dim words As String() = { "file", "sıfır", "Dženana" }
Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture,
New CultureInfo("en-US"),
New CultureInfo("tr-TR") }
For Each word In words
sw.WriteLine("{0}:", word)
For Each culture In cultures
Dim name As String = If(String.IsNullOrEmpty(culture.Name),
"Invariant", culture.Name)
Dim upperWord As String = word.ToUpper(culture)
sw.WriteLine(" {0,10}: {1,7} {2, 38}", name,
upperWord, ShowHexValue(upperWord))
Next
sw.WriteLine()
Next
sw.Close()
End Sub
Private Function ShowHexValue(s As String) As String
Dim retval As String = Nothing
For Each ch In s
Dim bytes() As Byte = BitConverter.GetBytes(ch)
retval += String.Format("{0:X2} {1:X2} ", bytes(1), bytes(0))
Next
Return retval
End Function
End Module
' 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
Analyse et mise en forme
La mise en forme et l’analyse sont des opérations inverses. Les règles de mise en forme déterminent comment convertir une valeur, telle qu’une date et une heure ou un nombre, en sa représentation sous forme de chaîne, tandis que les règles d’analyse déterminent comment convertir une représentation sous forme de chaîne en une valeur telle qu’une date et une heure. Les règles de mise en forme et d’analyse dépendent 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 produire une chaîne de date, il n’est pas possible de savoir si le 01/03/2011, le 1/3/2011 et le 03/01/2011 représentent le 3 janvier 2011 ou le 1er mars 2011.
using namespace System;
using namespace System::Globalization;
void main()
{
DateTime^ date = gcnew DateTime(2011, 3, 1);
array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture,
gcnew CultureInfo("en-US"),
gcnew CultureInfo("fr-FR") };
for each (CultureInfo^ 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
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
open System
open System.Globalization
let date = DateTime(2011, 3, 1)
let cultures =
[| CultureInfo.InvariantCulture
CultureInfo "en-US"
CultureInfo "fr-FR" |]
for culture in cultures do
printfn $"""{(if String.IsNullOrEmpty culture.Name then "Invariant" else culture.Name),-12} {date.ToString("d", culture)}"""
// The example displays the following output:
// Invariant 03/01/2011
// en-US 3/1/2011
// fr-FR 01/03/2011
Imports System.Globalization
Module Example
Public Sub Main()
Dim dat As Date = #3/1/2011#
Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture,
New CultureInfo("en-US"),
New CultureInfo("fr-FR") }
For Each culture In cultures
Console.WriteLine("{0,-12} {1}", If(String.IsNullOrEmpty(culture.Name),
"Invariant", culture.Name),
dat.ToString("d", culture))
Next
End Sub
End Module
' 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 seule chaîne peut produire des dates différentes en fonction de la culture dont les conventions sont utilisées dans l’opération d’analyse.
using namespace System;
using namespace System::Globalization;
void main()
{
String^ dateString = "07/10/2011";
array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { 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");
for each (CultureInfo^ 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
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
open System
open System.Globalization
let dateString = "07/10/2011"
let cultures =
[| CultureInfo.InvariantCulture
CultureInfo.CreateSpecificCulture "en-GB"
CultureInfo.CreateSpecificCulture "en-US" |]
printfn $"""{"Date String",-12} {"Culture",10} {"Month",8} {"Day",8}\n"""
for culture in cultures do
let date = DateTime.Parse(dateString, culture)
printfn $"""{dateString,-12} {(if String.IsNullOrEmpty culture.Name then "Invariant" else culture.Name),10} {date.Month,8} {date.Day,8}"""
// 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
Imports System.Globalization
Module Example
Public Sub Main()
Dim dateString As String = "07/10/2011"
Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture,
CultureInfo.CreateSpecificCulture("en-GB"),
CultureInfo.CreateSpecificCulture("en-US") }
Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", "Date String", "Culture",
"Month", "Day")
Console.WriteLine()
For Each culture In cultures
Dim dat As Date = DateTime.Parse(dateString, culture)
Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString,
If(String.IsNullOrEmpty(culture.Name),
"Invariant", culture.Name),
dat.Month, dat.Day)
Next
End Sub
End Module
' 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
Comparaison et tri de chaînes
Les conventions de comparaison et de tri des chaînes varient d’une culture à l’autre. Par exemple, l’ordre de tri peut être basé sur la phonétique ou sur la représentation visuelle des 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 ou ne pas respecter la casse, et les règles de casse peuvent différer selon la culture. La comparaison ordinale, en revanche, utilise les points de code Unicode de caractères individuels dans une chaîne lors de la comparaison et du tri des chaînes.
Les règles de tri déterminent l’ordre alphabétique des caractères Unicode et la façon dont deux chaînes se comparent. Par exemple, la String.Compare(String, String, StringComparison) méthode compare deux chaînes en fonction du 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 l’anglais américain, le premier appel à la méthode (à l’aide d’une comparaison sensible à la String.Compare(String, String, StringComparison) culture) considère que « a » est inférieur à « A », mais le deuxième appel à la même méthode (à l’aide de la comparaison ordinale) considère « a » supérieur à « A ».
using namespace System;
using namespace System::Globalization;
using namespace System::Threading;
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
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
open System
open System.Globalization
open System.Threading
Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-US"
printfn $"""{String.Compare("A", "a", StringComparison.CurrentCulture)}"""
printfn $"""{String.Compare("A", "a", StringComparison.Ordinal)}"""
// The example displays the following output:
// 1
// -32
Imports System.Globalization
Imports System.Threading
Module Example
Public Sub Main()
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
Console.WriteLine(String.Compare("A", "a", StringComparison.CurrentCulture))
Console.WriteLine(String.Compare("A", "a", StringComparison.Ordinal))
End Sub
End Module
' The example displays the following output:
' 1
' -32
.NET prend en charge les règles de tri des mots, des chaînes et des règles de tri ordinales :
Un tri de mots effectue une comparaison de chaînes sensibles à la culture dans laquelle certains caractères Unicode non alphabétiques peuvent avoir des pondérations spéciales. Par exemple, le trait d’union (-) peut avoir un poids très faible qui lui est attribué afin que « coop » et « co-op » apparaissent l’un à côté de l’autre dans une liste triée. Pour obtenir la liste des méthodes qui comparent deux chaînes à l’aide String de règles de tri de mots, consultez la section Opérations de chaîne par catégorie .
Un tri de chaîne effectue également une comparaison qui respecte la culture. Il est similaire à un tri de mots, sauf qu’il n’y a pas de cas spéciaux, et tous les symboles non alphanumériques sont antérieurs à tous les caractères Unicode alphanumériques. Deux chaînes peuvent être comparées à l’aide de règles de tri de chaîne en appelant les CompareInfo.Compare surcharges de méthode qui ont un
optionsparamètre qui a une valeur de CompareOptions.StringSort. Notez qu’il s’agit de la seule méthode que .NET fournit pour comparer deux chaînes à l’aide de règles de tri de chaîne.Un tri ordinal compare les chaînes en fonction de la valeur numérique de chaque Char objet dans la chaîne. Une comparaison ordinale respecte automatiquement la casse, car les versions minuscules et majuscules d’un caractère ont des points de code différents. Toutefois, si la casse n’est pas importante, vous pouvez spécifier une comparaison ordinale qui ignore la casse. Cela revient à convertir la chaîne en majuscules à l’aide de la culture invariante, puis à effectuer une comparaison ordinale sur le résultat. Pour obtenir la liste des méthodes qui comparent deux chaînes à l’aide String de règles de tri ordinales, consultez la section Opérations de chaîne par catégorie .
Une comparaison sensible à la culture est toute comparaison qui utilise explicitement ou implicitement un CultureInfo objet, y compris la culture invariante spécifiée par la CultureInfo.InvariantCulture propriété . La culture implicite est la culture actuelle, qui est spécifiée par les Thread.CurrentCulture propriétés et CultureInfo.CurrentCulture . L’ordre de tri des caractères alphabétiques (c’est-à-dire les caractères pour lesquels la Char.IsLetter propriété retourne true) varie considérablement d’une culture à l’autre. Vous pouvez spécifier une comparaison sensible à la culture qui utilise les conventions d’une culture spécifique en fournissant un CultureInfo objet à une méthode de comparaison de chaînes telle que Compare(String, String, CultureInfo, CompareOptions). Vous pouvez spécifier une comparaison sensible à la culture qui utilise les conventions de la culture actuelle en StringComparison.CurrentCulturefournissant , StringComparison.CurrentCultureIgnoreCaseou tout membre de l’énumération CompareOptions autre que CompareOptions.Ordinal ou CompareOptions.OrdinalIgnoreCase à une surcharge appropriée de la Compare méthode. Une comparaison sensible à la culture est généralement appropriée pour le tri, contrairement à une comparaison ordinale. Une comparaison ordinale est généralement appropriée pour déterminer si deux chaînes sont égales (c’est-à-dire, pour déterminer l’identité), alors qu’une comparaison sensible à la culture ne l’est pas.
L’exemple suivant illustre la différence entre la comparaison ordinale et sensible à la culture. L’exemple évalue trois chaînes, « Apple », « Æble » et « AEble », en utilisant la comparaison ordinale et les conventions des cultures da-DK et en-US (chacune d’elles étant 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 lettre individuelle et le trie après « Z » dans l’alphabet, la chaîne « Æble » est supérieure à « Apple ». Toutefois, « Æble » n’est pas considéré comme équivalent à « AEble », donc « Æble » est également supérieur à « AEble ». La culture en-US n’inclut pas la lettre « Æ », mais la traite comme équivalente à « AE », ce qui explique pourquoi « Æble » est inférieur à « Apple » mais égal à « AEble ». La comparaison ordinale, en revanche, considère que « Apple » est inférieur à « Æble », et « Æble » comme étant supérieur à « 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
open System
open System.Globalization
open System.Threading
let str1 = "Apple"
let str2 = "Æble"
let str3 = "AEble"
// Set the current culture to Danish in Denmark.
Thread.CurrentThread.CurrentCulture <- CultureInfo "da-DK"
printfn $"Current culture: {CultureInfo.CurrentCulture.Name}"
printfn $"Comparison of {str1} with {str2}: {String.Compare(str1, str2)}"
printfn $"Comparison of {str2} with {str3}: {String.Compare(str2, str3)}\n"
// Set the current culture to English in the U.S.
Thread.CurrentThread.CurrentCulture <- CultureInfo "en-US"
printfn $"Current culture: {CultureInfo.CurrentCulture.Name}"
printfn $"Comparison of {str1} with {str2}: {String.Compare(str1, str2)}"
printfn $"Comparison of {str2} with {str3}: {String.Compare(str2, str3)}\n"
// Perform an ordinal comparison.
printfn "Ordinal comparison"
printfn $"Comparison of {str1} with {str2}: {String.Compare(str1, str2, StringComparison.Ordinal)}"
printfn $"Comparison of {str2} with {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
Imports System.Globalization
Imports System.Threading
Public Module Example
Public Sub Main()
Dim str1 As String = "Apple"
Dim str2 As String = "Æble"
Dim str3 As String = "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}",
str2, str3, String.Compare(str2, str3))
Console.WriteLine()
' 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}",
str2, str3, String.Compare(str2, str3))
Console.WriteLine()
' 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))
End Sub
End Module
' 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
Utilisez les instructions générales suivantes pour choisir une méthode de tri ou de comparaison de chaînes appropriée :
Si vous souhaitez que les chaînes soient triées en fonction de la culture de l’utilisateur, vous devez les classer en fonction des conventions de la culture actuelle. Si la culture de l’utilisateur change, l’ordre des chaînes triées change é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 soient triées en fonction des 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 enseigner aux étudiants une langue particulière, vous souhaitez que les chaînes soient triées en fonction des conventions de l’une des cultures qui parle cette langue.
Si vous souhaitez que l’ordre des chaînes reste inchangé d’une culture à l’autre, vous devez les classer en fonction des conventions de la culture invariante ou utiliser une comparaison ordinale. Par exemple, vous utiliseriez un tri ordinal pour organiser les noms des fichiers, des processus, des mutex ou des 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 effectuer un test ordinal d’égalité en appelant une surcharge de la Equals méthode.
Notes
Les règles de tri et de casse qui respectent la culture utilisées dans la comparaison de chaînes dépendent de la version de .NET. Sur .NET Core, la comparaison de chaînes dépend de la version de la norme Unicode prise en charge par le système d’exploitation sous-jacent. Dans .NET Framework 4.5 et versions ultérieures s’exécutant sur Windows 8 ou ultérieur, le tri, la casse, la normalisation et les informations sur les caractères Unicode sont conformes à la norme Unicode 6.0. Sur les autres systèmes d’exploitation Windows, ils sont conformes à la norme Unicode 5.0.
Pour plus d’informations sur les règles de mot, de chaîne et de tri ordinal, consultez la System.Globalization.CompareOptions rubrique . Pour obtenir des recommandations supplémentaires sur l’utilisation de chaque règle, consultez Meilleures pratiques pour l’utilisation de chaînes.
En règle générale, vous n’appelez pas de méthodes de comparaison de chaînes telles que Compare directement pour déterminer l’ordre de tri des chaînes. Au lieu de cela, les méthodes de comparaison sont appelées en triant des méthodes telles que Array.Sort ou List<T>.Sort. L’exemple suivant effectue quatre opérations de tri différentes (le tri de mots à l’aide de la culture actuelle, le tri de mot à l’aide de la culture invariante, le tri ordinal et le tri de chaîne à l’aide de la culture invariante) sans appeler explicitement une 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 des chaînes dans son tableau.
using namespace System;
using namespace System::Collections;
using namespace System::Collections::Generic;
using namespace System::Globalization;
// IComparer<String> implementation to perform string sort.
ref class SCompare : System::Collections::Generic::IComparer<String^>
{
public:
SCompare() {};
virtual int Compare(String^ x, String^ y)
{
return CultureInfo::CurrentCulture->CompareInfo->Compare(x, y, CompareOptions::StringSort);
}
};
void main()
{
array<String^>^ strings = gcnew array<String^> { "coop", "co-op", "cooperative",
L"co\x00ADoperative", L"c�ur", "coeur" };
// Perform a word sort using the current (en-US) culture.
array<String^>^ current = gcnew array<String^>(strings->Length);
strings->CopyTo(current, 0);
Array::Sort(current, StringComparer::CurrentCulture);
// Perform a word sort using the invariant culture.
array<String^>^ invariant = gcnew array<String^>(strings->Length);
strings->CopyTo(invariant, 0);
Array::Sort(invariant, StringComparer::InvariantCulture);
// Perform an ordinal sort.
array<String^>^ ordinal = gcnew array<String^>(strings->Length);
strings->CopyTo(ordinal, 0);
Array::Sort(ordinal, StringComparer::Ordinal);
// Perform a string sort using the current culture.
array<String^>^ stringSort = gcnew array<String^>(strings->Length);
strings->CopyTo(stringSort, 0);
Array::Sort(stringSort, gcnew 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] );
}
// 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
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
// cooperative co-op co-op cooperative coop
// cœur cooperative cooperative cooperative cooperative
// coeur cooperative cooperative cœur cooperative
open System
open System.Collections.Generic
open System.Globalization
// IComparer<String> implementation to perform string sort using an F# object expression.
let scompare =
{ new IComparer<String> with
member _.Compare(x, y) =
CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort) }
let strings = [| "coop"; "co-op"; "cooperative"; "co\u00ADoperative"; "cœur"; "coeur" |]
// Perform a word sort using the current (en-US) culture.
let current = Array.copy strings
Array.Sort(current, StringComparer.CurrentCulture)
// Perform a word sort using the invariant culture.
let invariant = Array.copy strings
Array.Sort(invariant, StringComparer.InvariantCulture)
// Perform an ordinal sort.
let ordinal = Array.copy strings
Array.Sort(ordinal, StringComparer.Ordinal)
// Perform a string sort using the current culture.
let stringSort = Array.copy strings
Array.Sort(stringSort, scompare)
// Display array values
printfn "%13s %13s %15s %13s %13s\n" "Original" "Word Sort" "Invariant Word" "Ordinal Sort" "String Sort"
for i = 0 to strings.Length - 1 do
printfn "%13s %13s %15s %13s %13s\n" strings[i] current[i] invariant[i] ordinal[i] stringSort[i]
// 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
// cooperative co-op co-op cooperative coop
// cœur cooperative cooperative cooperative cooperative
// coeur cooperative cooperative cœur cooperative
Imports System.Collections
Imports System.Collections.Generic
Imports System.Globalization
Module Example
Public Sub Main()
Dim strings() As String = { "coop", "co-op", "cooperative",
"co" + ChrW(&h00AD) + "operative",
"cœur", "coeur" }
' Perform a word sort using the current (en-US) culture.
Dim current(strings.Length - 1) As String
strings.CopyTo(current, 0)
Array.Sort(current, StringComparer.CurrentCulture)
' Perform a word sort using the invariant culture.
Dim invariant(strings.Length - 1) As String
strings.CopyTo(invariant, 0)
Array.Sort(invariant, StringComparer.InvariantCulture)
' Perform an ordinal sort.
Dim ordinal(strings.Length - 1) As String
strings.CopyTo(ordinal, 0)
Array.Sort(ordinal, StringComparer.Ordinal)
' Perform a string sort using the current culture.
Dim stringSort(strings.Length - 1) As String
strings.CopyTo(stringSort, 0)
Array.Sort(stringSort, new SCompare())
' Display array values
Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}",
"Original", "Word Sort", "Invariant Word",
"Ordinal Sort", "String Sort")
Console.WriteLine()
For ctr As Integer = 0 To strings.Length - 1
Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}",
strings(ctr), current(ctr), invariant(ctr),
ordinal(ctr), stringSort(ctr))
Next
End Sub
End Module
' IComparer<String> implementation to perform string sort.
Friend Class SCompare : Implements IComparer(Of String)
Public Function Compare(x As String, y As String) As Integer _
Implements IComparer(Of String).Compare
Return CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort)
End Function
End Class
' 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
' cooperative co-op co-op cooperative coop
' cœur cooperative cooperative cooperative cooperative
' coeur cooperative cooperative cœur cooperative
Conseil
En interne, .NET utilise des clés de tri pour prendre en charge la comparaison de chaînes sensibles à la culture. 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ée par la SortKey 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 de recherche ou de tri sur le même ensemble de chaînes, vous pouvez améliorer ses performances en générant et en stockant des clés de tri pour toutes les chaînes qu’elle utilise. Lorsqu’une opération de tri ou de comparaison est requise, vous utilisez les clés de tri au lieu des chaînes. Pour plus d'informations, consultez la classe SortKey.
Si vous ne spécifiez pas de convention de comparaison de chaînes, les méthodes de tri telles que Array.Sort(Array) effectuent un tri respectant la culture et la casse sur les chaînes. L’exemple suivant montre comment la modification de la culture actuelle affecte l’ordre des chaînes triées dans un tableau. Elle 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 obtenu est basé sur les conventions de tri pour la culture anglaise (É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
open System
open System.Globalization
open System.Threading
let printIndexAndValues (myArray: string[]) =
for i = myArray.GetLowerBound 0 to myArray.GetUpperBound 0 do
printfn $"[{i}]: {myArray[i]}"
printfn ""
// Create and initialize a new array to store the strings.
let stringArray = [| "Apple"; "Æble"; "Zebra" |]
// Display the values of the array.
printfn "The original string array:"
printIndexAndValues stringArray
// Set the CurrentCulture to "en-US".
Thread.CurrentThread.CurrentCulture <- CultureInfo "en-US"
// Sort the values of the array.
Array.Sort stringArray
// Display the values of the array.
printfn "After sorting for the culture \"en-US\":"
printIndexAndValues stringArray
// Set the CurrentCulture to "da-DK".
Thread.CurrentThread.CurrentCulture <- CultureInfo "da-DK"
// Sort the values of the Array.
Array.Sort stringArray
// Display the values of the array.
printfn "After sorting for the culture \"da-DK\":"
printIndexAndValues stringArray
// 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
Imports System.Globalization
Imports System.IO
Imports System.Threading
Public Class TextToFile
Public Shared Sub Main()
' Creates and initializes a new array to store
' these date/time objects.
Dim stringArray() As String = { "Apple", "Æble", "Zebra"}
' Displays 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 ""en-US"" culture:")
PrintIndexAndValues(stringArray)
' Set the CurrentCulture to "da-DK".
Thread.CurrentThread.CurrentCulture = New CultureInfo("da-DK")
' Sort the values of the Array.
Array.Sort(stringArray)
' Displays the values of the Array.
Console.WriteLine("After sorting for the culture ""da-DK"":")
PrintIndexAndValues(stringArray)
End Sub
Public Shared Sub PrintIndexAndValues(myArray() As String)
For i As Integer = myArray.GetLowerBound(0) To myArray.GetUpperBound(0)
Console.WriteLine("[{0}]: {1}", i, myArray(i))
Next
Console.WriteLine()
End Sub
End Class
' 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
Avertissement
Si votre objectif principal en comparant des chaînes est de 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. La String.Compare méthode est principalement destinée à trier les chaînes.
Les méthodes de recherche de chaînes, telles que String.StartsWith et String.IndexOf, peuvent également effectuer des comparaisons de chaînes ordinales ou sensibles à la culture. L’exemple suivant illustre les différences entre les comparaisons ordinales et culturelles à l’aide de la IndexOf méthode . Une recherche sensible à la culture dans laquelle la culture actuelle est l’anglais (États-Unis) considère que la sous-chaîne « oe » correspond à la ligature « œ ». Étant donné qu’un trait d’union doux (U+00AD) est un caractère de largeur nulle, la recherche traite le trait d’union doux comme équivalent à Empty et trouve une correspondance au début de la chaîne. En revanche, une recherche ordinale ne trouve pas de correspondance dans les deux cas.
using namespace System;
void FindInString(String^ s, String^ substring, StringComparison options);
void main()
{
// Search for "oe" and "�u" in "�ufs" and "oeufs".
String^ s1 = L"�ufs";
String^ s2 = L"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 = L"co\x00ADoperative";
FindInString(s3, L"\x00AD", StringComparison::CurrentCulture);
FindInString(s3, L"\x00AD", StringComparison::Ordinal);
}
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 oufs at position 0
// 'oe' not found in oufs
// 'ou' found in oeufs at position 0
// 'ou' not found in oeufs
//
// '-' found in co-operative at position 0
// '-' found in co-operative at position 2
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 cooperative at position 0
// '' found in cooperative at position 2
open System
let findInString (s: string) (substring: string) (options: StringComparison) =
let result = s.IndexOf(substring, options)
if result <> -1 then
printfn $"'{substring}' found in {s} at position {result}"
else
printfn $"'{substring}' not found in {s}"
// Search for "oe" and "œu" in "œufs" and "oeufs".
let s1 = "œufs"
let s2 = "oeufs"
findInString s1 "oe" StringComparison.CurrentCulture
findInString s1 "oe" StringComparison.Ordinal
findInString s2 "œu" StringComparison.CurrentCulture
findInString s2 "œu" StringComparison.Ordinal
printfn ""
let s3 = "co\u00ADoperative"
findInString s3 "\u00AD" StringComparison.CurrentCulture
findInString s3 "\u00AD" StringComparison.Ordinal
// 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 cooperative at position 0
// '' found in cooperative at position 2
Module Example
Public Sub Main()
' Search for "oe" and "œu" in "œufs" and "oeufs".
Dim s1 As String = "œufs"
Dim s2 As String = "oeufs"
FindInString(s1, "oe", StringComparison.CurrentCulture)
FindInString(s1, "oe", StringComparison.Ordinal)
FindInString(s2, "œu", StringComparison.CurrentCulture)
FindInString(s2, "œu", StringComparison.Ordinal)
Console.WriteLine()
Dim softHyphen As String = ChrW(&h00AD)
Dim s3 As String = "co" + softHyphen + "operative"
FindInString(s3, softHyphen, StringComparison.CurrentCulture)
FindInString(s3, softHyphen, StringComparison.Ordinal)
End Sub
Private Sub FindInString(s As String, substring As String,
options As StringComparison)
Dim result As Integer = 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)
End If
End Sub
End Module
' 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 cooperative at position 0
' '' found in cooperative at position 2
Rechercher dans des chaînes
Les méthodes de recherche de chaînes, telles que String.StartsWith et String.IndexOf, peuvent également effectuer des comparaisons de chaînes ordinales ou de culture pour déterminer si un caractère ou une sous-chaîne se trouve dans une chaîne spécifiée.
Les méthodes de recherche de la String classe qui recherchent un caractère individuel, tel que la IndexOf méthode, ou l’un des ensembles de caractères, comme la IndexOfAny méthode, effectuent toutes une recherche ordinale. Pour effectuer une recherche sensible à la culture d’un caractère, vous devez appeler une CompareInfo méthode telle que CompareInfo.IndexOf(String, Char) ou CompareInfo.LastIndexOf(String, Char). Notez que les résultats de la recherche d’un caractère à l’aide d’une comparaison ordinale et sensible à la culture peuvent être très différents. Par exemple, une recherche d’un caractère Unicode précomposé tel que la ligature « Æ » (U+00C6) peut correspondre à n’importe quelle occurrence de ses composants dans la séquence correcte, telle que « AE » (U+041U+0045), en fonction de la culture. L’exemple suivant illustre la différence entre les méthodes et CompareInfo.IndexOf(String, Char) lors de la String.IndexOf(Char) recherche d’un caractère individuel. La ligature « æ » (U+00E6) se trouve dans la chaîne « aerial » lors de l’utilisation des conventions de la culture en-US, mais pas lors de l’utilisation des conventions de la culture da-DK ou lors d’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
open System.Globalization
let cultureNames = [| "da-DK"; "en-US" |]
let str = "aerial"
let ch = 'æ' // U+00E6
printf "Ordinal comparison -- "
printfn $"Position of '{ch}' in {str}: {str.IndexOf ch}"
for cultureName in cultureNames do
let ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo
printf $"{cultureName} cultural comparison -- "
printfn $"Position of '{ch}' in {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
Imports System.Globalization
Module Example
Public Sub Main()
Dim cultureNames() As String = { "da-DK", "en-US" }
Dim ci As CompareInfo
Dim str As String = "aerial"
Dim ch As Char = "æ"c ' U+00E6
Console.Write("Ordinal comparison -- ")
Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
str.IndexOf(ch))
For Each 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))
Next
End Sub
End Module
' 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 classe qui recherchent une chaîne plutôt qu’un caractère effectuent une recherche sensible à la culture si les options de recherche ne sont pas explicitement spécifiées par un paramètre de type StringComparison. La seule exception est Contains, qui effectue une recherche ordinale.
Test de l’égalité
Utilisez la String.Compare méthode pour déterminer la relation de deux chaînes dans l’ordre de tri. En règle générale, il s’agit d’une opération qui respecte la culture. En revanche, appelez la String.Equals méthode pour tester l’égalité. Étant donné que le test d’égalité compare généralement l’entrée utilisateur à une chaîne connue, telle qu’un nom d’utilisateur valide, un mot de passe ou un chemin d’accès au système de fichiers, il s’agit généralement d’une opération ordinale.
Avertissement
Il est possible de tester l’égalité en appelant la String.Compare méthode et en déterminant si la valeur de retour est égale à zéro. Toutefois, cette pratique n’est pas recommandée. Pour déterminer si deux chaînes sont égales, vous devez appeler l’une des surcharges de la String.Equals méthode . La surcharge préférée à appeler est la méthode instance Equals(String, StringComparison) ou la méthode statiqueEquals(String, String, StringComparison), car les deux méthodes incluent un System.StringComparison paramètre qui spécifie explicitement le type de comparaison.
L’exemple suivant illustre le danger d’effectuer une comparaison sensible à la culture pour l’égalité quand un ordinal doit être utilisé à la place. Dans ce cas, l’objectif du code est d’interdire l’accès au système de fichiers des URL qui commencent par « FILE:// » ou « file:// » en effectuant une comparaison qui ne respecte pas la casse du début d’une URL avec la chaîne « FILE:// ». Toutefois, si une comparaison sensible à la culture est effectuée à l’aide de la culture turque (Turquie) sur une URL qui commence par « file:// », la comparaison de l’égalité échoue, car l’équivalent en majuscules turques du « i » minuscule est « İ » au lieu de « I ». Par conséquent, l’accès au système de fichiers est autorisé par inadvertance. En revanche, si une comparaison ordinale est effectuée, la comparaison d’égalité réussit et l’accès au système de fichiers est refusé.
using namespace System;
using namespace System::Globalization;
using namespace System::Threading;
bool TestForEquality(String^ str, StringComparison cmp);
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);
}
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.
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.
open System
open System.Globalization
open System.Threading
let testForEquality (str: string) (cmp: StringComparison) =
let position = str.IndexOf "://"
if position < 0 then false
else
let substring = str.Substring(0, position)
substring.Equals("FILE", cmp)
Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "tr-TR"
let filePath = "file://c:/notes.txt"
printfn "Culture-sensitive test for equality:"
if not (testForEquality filePath StringComparison.CurrentCultureIgnoreCase) then
printfn $"Access to {filePath} is allowed."
else
printfn $"Access to {filePath} is not allowed."
printfn "\nOrdinal test for equality:"
if not (testForEquality filePath StringComparison.OrdinalIgnoreCase) then
printfn $"Access to {filePath} is allowed."
else
printfn $"Access to {filePath} is not allowed."
// 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.
Imports System.Globalization
Imports System.Threading
Module Example
Public Sub Main()
Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR")
Dim filePath As String = "file://c:/notes.txt"
Console.WriteLine("Culture-sensitive test for equality:")
If Not TestForEquality(filePath, StringComparison.CurrentCultureIgnoreCase) Then
Console.WriteLine("Access to {0} is allowed.", filePath)
Else
Console.WriteLine("Access to {0} is not allowed.", filePath)
End If
Console.WriteLine()
Console.WriteLine("Ordinal test for equality:")
If Not TestForEquality(filePath, StringComparison.OrdinalIgnoreCase) Then
Console.WriteLine("Access to {0} is allowed.", filePath)
Else
Console.WriteLine("Access to {0} is not allowed.", filePath)
End If
End Sub
Private Function TestForEquality(str As String, cmp As StringComparison) As Boolean
Dim position As Integer = str.IndexOf("://")
If position < 0 Then Return False
Dim substring As String = str.Substring(0, position)
Return substring.Equals("FILE", cmp)
End Function
End Module
' The example displays the following output:
' Culture-sensitive test for equality:
' Access to file://c:/notes.txt is allowed.
'
' Ordinal test for equality:
' Access to file://c:/notes.txt is not allowed.
Normalisation
Certains caractères Unicode ont plusieurs représentations. Par exemple, l’un des points de code suivants 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 correspondance et d’autres opérations de chaîne.
La norme Unicode définit un processus appelé normalisation qui retourne une représentation binaire d’un caractère Unicode pour l’une de ses représentations binaires équivalentes. La normalisation peut utiliser plusieurs algorithmes, appelés formulaires de normalisation, qui suivent différentes règles. .NET prend en charge les formulaires de normalisation Unicode C, D, KC et KD. Lorsque les chaînes ont été normalisées au même formulaire de normalisation, elles peuvent être comparées à l’aide de la comparaison ordinale.
Une comparaison ordinale est une comparaison binaire de la valeur scalaire Unicode des objets correspondants Char dans chaque chaîne. La String classe inclut un certain nombre de méthodes qui peuvent effectuer une comparaison ordinale, notamment les suivantes :
Toute surcharge des Compareméthodes , Equals, StartsWithEndsWith, , IndexOfet LastIndexOf qui inclut un StringComparison paramètre . La méthode effectue une comparaison ordinale si vous fournissez une valeur de StringComparison.Ordinal ou OrdinalIgnoreCase pour ce paramètre.
Surcharges de la CompareOrdinal méthode.
Méthodes qui utilisent la comparaison ordinale par défaut, telles que Contains, Replaceet Split.
Méthodes qui recherchent une Char valeur ou les éléments d’un Char tableau dans une chaîne instance. Ces méthodes incluent IndexOf(Char) et Split(Char[]).
Vous pouvez déterminer si une chaîne est normalisée au format de normalisation C en appelant la 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 la String.Normalize() méthode pour convertir une chaîne en forme de normalisation C, ou vous pouvez appeler la String.Normalize(NormalizationForm) méthode pour convertir une chaîne en un formulaire de normalisation spécifié. Pour obtenir des informations détaillées sur la normalisation et la comparaison des chaînes, consultez les Normalize() méthodes et Normalize(NormalizationForm) .
L’exemple simple suivant illustre la normalisation des chaînes. Il définit la lettre « ố » de trois manières différentes dans trois chaînes différentes, et utilise une comparaison ordinale pour l’égalité pour déterminer que chaque chaîne diffère des deux autres chaînes. Il convertit ensuite chaque chaîne en formes de normalisation prises en charge, puis effectue à nouveau une comparaison ordinale de chaque chaîne dans un formulaire de normalisation spécifié. Dans chaque cas, le deuxième test d’égalité montre que les chaînes sont égales.
using namespace System;
using namespace System::Globalization;
using namespace System::IO;
using namespace System::Text;
public ref class Example
{
private:
StreamWriter^ sw;
void TestForEquality(... array<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));
}
String^ ShowBytes(String^ str)
{
String^ result = nullptr;
for each (Char ch in str)
result += String::Format("{0} ", Convert::ToUInt16(ch).ToString("X4"));
return result->Trim();
}
array<String^>^ NormalizeStrings(NormalizationForm nf, ... array<String^>^ words)
{
for (int ctr = 0; ctr < words->Length; ctr++)
if (! words[ctr]->IsNormalized(nf))
words[ctr] = words[ctr]->Normalize(nf);
return words;
}
public:
void Execute()
{
sw = gcnew StreamWriter(".\\TestNorm1.txt");
// Define three versions of the same word.
String^ s1 = L"sống"; // create word with U+1ED1
String^ s2 = L"s\x00F4\x0301ng";
String^ s3 = L"so\x0302\x0301ng";
TestForEquality(s1, s2, s3);
sw->WriteLine();
// Normalize and compare strings using each normalization form.
for each (String^ formName in Enum::GetNames(NormalizationForm::typeid))
{
sw->WriteLine("Normalization {0}:\n", formName);
NormalizationForm nf = (NormalizationForm) Enum::Parse(NormalizationForm::typeid, formName);
array<String^>^ sn = NormalizeStrings(nf, s1, s2, s3 );
TestForEquality(sn);
sw->WriteLine("\n");
}
sw->Close();
}
};
void main()
{
Example^ ex = gcnew Example();
ex->Execute();
}
// The example produces the following output:
// 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
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 += $"{(ushort)ch: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
open System
open System.IO
open System.Text
do
use sw = new StreamWriter(@".\TestNorm1.txt")
let showBytes (str: string) =
let mutable result = ""
for ch in str do
result <- result + $"{uint16 ch:X4} "
result.Trim()
let testForEquality (words: string[]) =
for ctr = 0 to words.Length - 2 do
for ctr2 = ctr + 1 to words.Length - 1 do
sw.WriteLine("{0} ({1}) = {2} ({3}): {4}",
words[ctr], showBytes(words[ctr]),
words[ctr2], showBytes(words[ctr2]),
words[ctr].Equals(words[ctr2], StringComparison.Ordinal))
let normalizeStrings nf (words: string[]) =
for i = 0 to words.Length - 1 do
if not (words[i].IsNormalized nf) then
words[i] <- words[i].Normalize nf
words
// Define three versions of the same word.
let s1 = "sống" // create word with U+1ED1
let s2 = "s\u00F4\u0301ng"
let s3 = "so\u0302\u0301ng"
testForEquality [| s1; s2; s3 |]
sw.WriteLine()
// Normalize and compare strings using each normalization form.
for formName in Enum.GetNames typeof<NormalizationForm> do
sw.WriteLine("Normalization {0}:\n", formName)
let nf = Enum.Parse(typeof<NormalizationForm>, formName) :?> NormalizationForm
let sn = normalizeStrings nf [| s1; s2; s3|]
testForEquality sn
sw.WriteLine "\n"
// 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
Imports System.Globalization
Imports System.IO
Imports System.Text
Module Example
Private sw As StreamWriter
Public Sub Main()
sw = New StreamWriter(".\TestNorm1.txt")
' Define three versions of the same word.
Dim s1 As String = "sống" ' create word with U+1ED1
Dim s2 AS String = "s" + ChrW(&h00F4) + ChrW(&h0301) + "ng"
Dim s3 As String = "so" + ChrW(&h0302) + ChrW(&h0301) + "ng"
TestForEquality(s1, s2, s3)
sw.WriteLine()
' Normalize and compare strings using each normalization form.
For Each formName In [Enum].GetNames(GetType(NormalizationForm))
sw.WriteLine("Normalization {0}:", formName)
Dim nf As NormalizationForm = CType([Enum].Parse(GetType(NormalizationForm), formName),
NormalizationForm)
Dim sn() As String = NormalizeStrings(nf, s1, s2, s3)
TestForEquality(sn)
sw.WriteLine(vbCrLf)
Next
sw.Close()
End Sub
Private Sub TestForEquality(ParamArray words As String())
For ctr As Integer = 0 To words.Length - 2
For ctr2 As Integer = ctr + 1 To words.Length - 1
sw.WriteLine("{0} ({1}) = {2} ({3}): {4}",
words(ctr), ShowBytes(words(ctr)),
words(ctr2), ShowBytes(words(ctr2)),
words(ctr).Equals(words(ctr2), StringComparison.Ordinal))
Next
Next
End Sub
Private Function ShowBytes(str As String) As String
Dim result As String = Nothing
For Each ch In str
result += String.Format("{0} ", Convert.ToUInt16(ch).ToString("X4"))
Next
Return result.Trim()
End Function
Private Function NormalizeStrings(nf As NormalizationForm, ParamArray words() As String) As String()
For ctr As Integer = 0 To words.Length - 1
If Not words(ctr).IsNormalized(nf) Then
words(ctr) = words(ctr).Normalize(nf)
End If
Next
Return words
End Function
End Module
' 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 les formulaires de normalisation et de normalisation, consultez System.Text.NormalizationForm, ainsi que l’Annexe standard Unicode n° 15 : Formulaires de normalisation Unicode et le FAQ sur la normalisation sur le site web unicode.org.
Opérations de chaîne par catégorie
La String classe fournit des membres pour comparer des chaînes, tester l’égalité des chaînes, rechercher des caractères ou sous-chaînes dans une chaîne, modifier une chaîne, extraire des sous-chaînes d’une chaîne, combiner des chaînes, mettre en forme des valeurs, copier une chaîne et normaliser une chaîne.
Comparer des chaînes
Vous pouvez comparer des chaînes pour déterminer leur position relative dans l’ordre de tri à l’aide des méthodes suivantes String :
Compare retourne un entier qui indique la relation d’une chaîne à une deuxième chaîne dans l’ordre de tri.
CompareOrdinal retourne un entier qui indique la relation d’une chaîne à une deuxième chaîne en fonction d’une comparaison de leurs points de code.
CompareToretourne un entier qui indique la relation de la chaîne actuelle instance à une deuxième chaîne dans l’ordre de tri. La CompareTo(String) méthode fournit les IComparable implémentations et IComparable<T> pour la String classe .
Tester l’égalité de chaînes
Vous appelez la Equals méthode pour déterminer si deux chaînes sont égales. Les instance Equals(String, String, StringComparison) et les surcharges statiques Equals(String, StringComparison) vous permettent de spécifier si la comparaison est sensible à la culture ou ordinale, et si la casse est prise en compte ou ignorée. La plupart des tests d’égalité sont ordinaux, et les comparaisons d’égalité qui déterminent l’accès à une ressource système (comme un objet de système de fichiers) doivent toujours être ordinales.
Rechercher des caractères dans une chaîne
La String classe comprend deux types de méthodes de recherche :
Méthodes qui retournent une Boolean valeur pour indiquer si une sous-chaîne particulière est présente dans une chaîne instance. Il s’agit notamment des Containsméthodes , EndsWithet StartsWith .
Méthodes qui indiquent la position de départ d’une sous-chaîne dans une chaîne instance. Il s’agit notamment des IndexOfméthodes , IndexOfAny, LastIndexOfet LastIndexOfAny .
Avertissement
Si vous souhaitez rechercher un modèle particulier dans une chaîne plutôt qu’une sous-chaîne spécifique, vous devez utiliser des expressions régulières. Pour plus d’informations, consultez Expressions régulières .NET.
Modifier une chaîne
La String classe inclut les méthodes suivantes qui semblent modifier la valeur d’une chaîne :
PadLeft insère une ou plusieurs occurrences d’un caractère spécifié au début d’une chaîne.
PadRight insère une ou plusieurs occurrences d’un caractère spécifié à la fin d’une chaîne.
Removesupprime une sous-chaîne de la instance actuelle String .
Replaceremplace une sous-chaîne par une autre sous-chaîne dans le instance actuel String .
ToLower et ToLowerInvariant convertissent tous les caractères d’une chaîne en minuscules.
ToUpper et ToUpperInvariant convertir tous les caractères d’une chaîne en majuscules.
Trim supprime toutes les occurrences d’un caractère du début et de la fin d’une chaîne.
TrimEnd supprime toutes les occurrences d’un caractère de la fin d’une chaîne.
TrimStart supprime toutes les occurrences d’un caractère du début d’une chaîne.
Important
Toutes les méthodes de modification de chaîne retournent un nouvel String objet. Ils ne modifient pas la valeur de la instance actuelle.
Extraire des sous-chaînes d’une chaîne
La String.Split méthode sépare une chaîne unique en plusieurs chaînes. Les surcharges de la méthode vous permettent de spécifier plusieurs délimiteurs, de limiter le nombre de sous-chaînes que la méthode extrait, de réduire les espaces blancs des sous-chaînes et de spécifier si des chaînes vides (qui se produisent lorsque des délimiteurs sont adjacents) sont incluses parmi les chaînes retournées.
Combiner des chaînes
Les méthodes suivantes String peuvent être utilisées pour la concaténation de chaînes :
Concat combine une ou plusieurs sous-chaînes en une seule chaîne.
Join concatène une ou plusieurs sous-chaînes dans un seul élément et ajoute un séparateur entre chaque sous-chaîne.
Valeurs de format
La String.Format méthode utilise la fonctionnalité de mise en forme composite pour remplacer un ou plusieurs espaces réservés dans une chaîne par la représentation sous forme de chaîne d’un objet ou d’une valeur. La 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 dans une chaîne.
Pour incorporer la représentation sous forme de chaîne d’un objet qui prend en charge l’interface IFormattable dans une chaîne.
Pour justifier à droite ou à gauche une sous-chaîne dans un champ d’une chaîne plus grande.
Pour obtenir des informations détaillées sur les opérations de mise en forme et des exemples, consultez le résumé de la Format surcharge.
Copier une chaîne
Vous pouvez appeler les méthodes suivantes String pour effectuer une copie d’une chaîne :
Copy crée une copie d’une chaîne existante.
CopyTo copie une partie d’une chaîne dans un tableau de caractères.
Normaliser une chaîne
En Unicode, un seul caractère peut avoir plusieurs points de code. La normalisation convertit ces caractères équivalents en la même représentation binaire. La String.Normalize méthode effectue la normalisation et la String.IsNormalized méthode détermine si une chaîne est normalisée.
Pour plus d’informations et un exemple, consultez la section Normalisation plus haut dans cette rubrique.
Constructeurs
| String(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. |
| String(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. |
| String(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. |
| String(Char[]) |
Initialise une nouvelle instance de la classe String en fonction des caractères Unicode indiqués dans le tableau de caractères spécifié. |
| String(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 de caractère dans ce tableau et une longueur. |
| String(ReadOnlySpan<Char>) |
Initialise une nouvelle instance de la classe String en fonction des caractères Unicode indiqués dans l’étendue en lecture seule spécifiée. |
| String(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. |
| String(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. |
| String(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. |
Champs
| Empty |
Représente la chaîne vide. Ce champ est en lecture seule. |
Propriétés
| Chars[Int32] |
Obtient l'objet Char à une position de caractère spécifiée dans l'objet String actuel. |
| Length |
Obtient le nombre de caractères de l'objet String actuel. |
Méthodes
| Clone() |
Retourne une référence à cette instance de String. |
| Compare(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. |
| Compare(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. |
| Compare(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. |
| Compare(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. |
| Compare(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. |
| Compare(String, String) |
Compare deux objets String spécifiés et retourne un entier qui indique leur position relative dans l'ordre de tri. |
| Compare(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. |
| Compare(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. |
| Compare(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. |
| Compare(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. |
| CompareOrdinal(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. |
| CompareOrdinal(String, String) |
Compare deux objets String spécifiés en évaluant les valeurs numériques des objets Char correspondants dans chaque chaîne. |
| CompareTo(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é. |
| CompareTo(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. |
| Concat(IEnumerable<String>) |
Concatène les membres d'une collection IEnumerable<T> construite de type String. |
| Concat(Object) |
Crée la représentation sous forme de chaîne d’un objet spécifié. |
| Concat(Object, Object) |
Concatène les représentations sous forme de chaîne de deux objets spécifiés. |
| Concat(Object, Object, Object) |
Concatène les représentations sous forme de chaîne de trois objets spécifiés. |
| Concat(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. |
| Concat(Object[]) |
Concatène les représentations sous forme de chaîne des éléments dans un tableau Object spécifié. |
| Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>) |
Concatène les représentations sous forme de chaîne de deux étendues de caractères en lecture seule spécifiées. |
| Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) |
Concatène les représentations sous forme de chaîne de trois étendues de caractères en lecture seule spécifiées. |
| Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) |
Concatène les représentations sous forme de chaîne de quatre étendues de caractères en lecture seule spécifiées. |
| Concat(String, String) |
Concatène deux instances spécifiées de String. |
| Concat(String, String, String) |
Concatène trois instances spécifiées de String. |
| Concat(String, String, String, String) |
Concatène quatre instances spécifiées de String. |
| Concat(String[]) |
Concatène les éléments d'un tableau String spécifié. |
| Concat<T>(IEnumerable<T>) |
Concatène les membres d'une implémentation IEnumerable<T>. |
| Contains(Char) |
Retourne une valeur qui indique si le caractère spécifié se trouve dans cette chaîne. |
| Contains(Char, StringComparison) |
Retourne une valeur qui indique si le caractère spécifié se trouve dans cette chaîne, en utilisant les règles de comparaison spécifiées. |
| Contains(String) |
Retourne une valeur qui indique si la sous-chaîne spécifiée apparaît dans cette chaîne. |
| Contains(String, StringComparison) |
Retourne une valeur qui indique si la chaîne spécifiée se trouve dans cette chaîne, en utilisant les règles de comparaison spécifiées. |
| Copy(String) |
Obsolète.
Crée une instance de String ayant la même valeur qu'un String spécifié. |
| CopyTo(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. |
| CopyTo(Span<Char>) |
Copie le contenu de cette chaîne dans l’étendue de destination. |
| Create(IFormatProvider, DefaultInterpolatedStringHandler) |
Crée une chaîne à l’aide du fournisseur spécifié pour contrôler la mise en forme de la chaîne interpolée spécifiée. |
| Create(IFormatProvider, Span<Char>, DefaultInterpolatedStringHandler) |
Crée une chaîne à l’aide du fournisseur spécifié pour contrôler la mise en forme de la chaîne interpolée spécifiée. |
| Create<TState>(Int32, TState, SpanAction<Char,TState>) |
Crée une chaîne d’une longueur spécifique et l’initialise ensuite à l’aide du rappel spécifié. |
| EndsWith(Char) |
Détermine si la fin de cette instance de chaîne correspond au caractère spécifié. |
| EndsWith(String) |
Détermine si la fin de cette instance de chaîne correspond à la chaîne spécifiée. |
| EndsWith(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. |
| EndsWith(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. |
| EnumerateRunes() |
Retourne une énumération de Rune à partir de cette chaîne. |
| Equals(Object) |
Détermine si cette instance et un objet spécifié, qui doit aussi être un objet String, ont la même valeur. |
| Equals(String) |
Détermine si cette instance et un autre objet String spécifié ont la même valeur. |
| Equals(String, String) |
Détermine si deux objets String spécifiés ont la même valeur. |
| Equals(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. |
| Equals(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. |
| Format(IFormatProvider, CompositeFormat, Object[]) |
Remplace le ou les éléments de format d’un CompositeFormat par la représentation sous forme de chaîne des objets correspondants dans le format spécifié. |
| Format(IFormatProvider, CompositeFormat, ReadOnlySpan<Object>) |
Remplace le ou les éléments de format d’un CompositeFormat par la représentation sous forme de chaîne des objets correspondants dans le format spécifié. |
| Format(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. |
| Format(IFormatProvider, String, Object, Object) |
Remplace les éléments de mise en forme dans une chaîne 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. |
| Format(IFormatProvider, String, Object, Object, Object) |
Remplace les éléments de mise en forme d’une chaîne 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. |
| Format(IFormatProvider, String, Object[]) |
Remplace les éléments de mise en forme d’une chaîne 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. |
| Format(String, Object) |
Remplace un ou plusieurs éléments de mise en forme d’une chaîne par la représentation sous forme de chaîne d’un objet spécifié. |
| Format(String, Object, Object) |
Remplace les éléments de mise en forme dans une chaîne par la représentation sous forme de chaîne de deux objets spécifiés. |
| Format(String, Object, Object, Object) |
Remplace les éléments de mise en forme d’une chaîne par la représentation sous forme de chaîne de trois objets spécifiés. |
| Format(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é. |
| Format<TArg0,TArg1,TArg2>(IFormatProvider, CompositeFormat, TArg0, TArg1, TArg2) |
Remplace le ou les éléments de format d’un CompositeFormat par la représentation sous forme de chaîne des objets correspondants dans le format spécifié. |
| Format<TArg0,TArg1>(IFormatProvider, CompositeFormat, TArg0, TArg1) |
Remplace le ou les éléments de format d’un CompositeFormat par la représentation sous forme de chaîne des objets correspondants dans le format spécifié. |
| Format<TArg0>(IFormatProvider, CompositeFormat, TArg0) |
Remplace le ou les éléments de format d’un CompositeFormat par la représentation sous forme de chaîne des objets correspondants dans le format spécifié. |
| GetEnumerator() |
Récupère un objet qui peut itérer au sein des caractères individuels de cette chaîne. |
| GetHashCode() |
Retourne le code de hachage pour cette chaîne. |
| GetHashCode(ReadOnlySpan<Char>) |
Retourne le code de hachage pour l’étendue de caractères en lecture seule fournie. |
| GetHashCode(ReadOnlySpan<Char>, StringComparison) |
Retourne le code de hachage pour l’étendue de caractères en lecture seule fournie, en utilisant les règles spécifiées. |
| GetHashCode(StringComparison) |
Retourne le code de hachage pour cette chaîne à l’aide des règles spécifiées. |
| GetPinnableReference() |
Retourne une référence à l’élément de la chaîne à l’index zéro. Cette méthode est destinée à prendre en charge les compilateurs .NET et n’est pas destinée à être appelée par le code utilisateur. |
| GetType() |
Obtient le Type de l'instance actuelle. (Hérité de Object) |
| GetTypeCode() | |
| IndexOf(Char) |
Signale l'index de base zéro de la première occurrence du caractère Unicode spécifié dans cette chaîne. |
| IndexOf(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. |
| IndexOf(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. |
| IndexOf(Char, StringComparison) |
Signale l'index de base zéro de la première occurrence du caractère Unicode spécifié dans cette chaîne. Un paramètre spécifie le type de recherche à utiliser pour le caractère spécifié. |
| IndexOf(String) |
Signale l'index de base zéro de la première occurrence de la chaîne spécifiée dans cette instance. |
| IndexOf(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. |
| IndexOf(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. |
| IndexOf(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. |
| IndexOf(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. |
| IndexOf(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. |
| IndexOfAny(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é. |
| IndexOfAny(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. |
| IndexOfAny(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. |
| Insert(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. |
| Intern(String) |
Récupère la référence du système au String spécifié. |
| IsInterned(String) |
Récupère une référence à un String spécifié. |
| IsNormalized() |
Indique si cette chaîne se trouve dans un formulaire de normalisation C Unicode. |
| IsNormalized(NormalizationForm) |
Indique si cette chaîne figure dans le formulaire de normalisation Unicode spécifié. |
| IsNullOrEmpty(String) |
Indique si la chaîne spécifiée est |
| IsNullOrWhiteSpace(String) |
Indique si une chaîne spécifiée est |
| Join(Char, Object[]) |
Concatène les représentations sous forme de chaînes d’un tableau d’objets, en utilisant le séparateur spécifié entre chaque membre. |
| Join(Char, String[]) |
Concatène un tableau de chaînes en utilisant le séparateur spécifié entre chaque membre. |
| Join(Char, String[], Int32, Int32) |
Concatène un tableau de chaînes en utilisant le séparateur spécifié entre chaque membre, en commençant par l’élément de |
| Join(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. |
| Join(String, Object[]) |
Concatène les éléments d'un tableau d'objets, en utilisant le séparateur spécifié entre chaque élément. |
| Join(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. |
| Join(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. |
| Join<T>(Char, IEnumerable<T>) |
Concatène les membres d’une collection, en utilisant le séparateur spécifié entre chaque membre. |
| Join<T>(String, IEnumerable<T>) |
Concatène les membres d’une collection, en utilisant le séparateur spécifié entre chaque membre. |
| LastIndexOf(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. |
| LastIndexOf(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. |
| LastIndexOf(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. |
| LastIndexOf(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. |
| LastIndexOf(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. |
| LastIndexOf(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. |
| LastIndexOf(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. |
| LastIndexOf(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. |
| LastIndexOf(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. |
| LastIndexOfAny(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. |
| LastIndexOfAny(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. |
| LastIndexOfAny(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. |
| MemberwiseClone() |
Crée une copie superficielle du Object actuel. (Hérité de Object) |
| Normalize() |
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 un formulaire de normalisation C Unicode. |
| Normalize(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é. |
| PadLeft(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. |
| PadLeft(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. |
| PadRight(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. |
| PadRight(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. |
| Remove(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. |
| Remove(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. |
| Replace(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é. |
| Replace(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. |
| Replace(String, String, Boolean, CultureInfo) |
Retourne une nouvelle chaîne dans laquelle toutes les occurrences d’une chaîne spécifique dans l’instance actuelle sont remplacées par une autre chaîne spécifique, à l’aide des informations fournies sur la culture et le respect de la casse. |
| Replace(String, String, StringComparison) |
Retourne une nouvelle chaîne dans laquelle toutes les occurrences d’une chaîne spécifique dans l’instance actuelle sont remplacées par une autre chaîne spécifique, à l’aide des informations fournies sur le type de comparaison. |
| ReplaceLineEndings() |
Remplace toutes les séquences de nouvelle ligne dans la chaîne actuelle par NewLine. |
| ReplaceLineEndings(String) |
Remplace toutes les séquences de nouvelle ligne dans la chaîne actuelle par |
| Split(Char, Int32, StringSplitOptions) |
Divise une chaîne en un nombre maximal de sous-chaînes en fonction d’un caractère de délimitation spécifié et, éventuellement, d’options. Divise une chaîne en un nombre maximal de sous-chaînes en fonction du séparateur de caractères fourni, en omettant éventuellement les sous-chaînes vides du résultat. |
| Split(Char, StringSplitOptions) |
Divise une chaîne en sous-chaînes en fonction d’un caractère de délimitation spécifié et, éventuellement, d’options. |
| Split(Char[]) |
Divise une chaîne en sous-chaînes en fonction de caractères de délimitation spécifiés. |
| Split(Char[], Int32) |
Divise une chaîne en un nombre maximal de sous-chaînes en fonction de caractères de délimitation spécifiés. |
| Split(Char[], Int32, StringSplitOptions) |
Divise une chaîne en un nombre maximal de sous-chaînes en fonction de caractères de délimitation spécifiés et, éventuellement, d’options. |
| Split(Char[], StringSplitOptions) |
Divise une chaîne en sous-chaînes en fonction de caractères de délimitation spécifiés et d’options. |
| Split(String, Int32, StringSplitOptions) |
Divise une chaîne en un nombre maximal de sous-chaînes en fonction d’une chaîne de délimitation spécifiée et, éventuellement, d’options. |
| Split(String, StringSplitOptions) |
Divise une chaîne en sous-chaînes d’après le séparateur de chaînes fourni. |
| Split(String[], Int32, StringSplitOptions) |
Divise une chaîne en un nombre maximal de sous-chaînes en fonction de chaînes de délimitation spécifiées et, éventuellement, d’options. |
| Split(String[], StringSplitOptions) |
Divise une chaîne en sous-chaînes en fonction d’une chaîne de délimitation spécifiée et, éventuellement, d’options. |
| StartsWith(Char) |
Détermine si cette instance de chaîne commence par le caractère spécifié. |
| StartsWith(String) |
Détermine si le début de cette instance de chaîne correspond à la chaîne spécifiée. |
| StartsWith(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. |
| StartsWith(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. |
| Substring(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. |
| Substring(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. |
| ToCharArray() |
Copie les caractères de cette instance vers un tableau de caractères Unicode. |
| ToCharArray(Int32, Int32) |
Copie les caractères d'une sous-chaîne spécifiée de cette instance vers un tableau de caractères Unicode. |
| ToLower() |
Retourne une copie de cette chaîne convertie en minuscules. |
| ToLower(CultureInfo) |
Retourne une copie de cette chaîne en minuscules, à l'aide des règles de casse de la culture spécifiée. |
| ToLowerInvariant() |
Retourne une copie de cet objet String converti en minuscules à l'aide des règles de casse de la culture indifférente. |
| ToString() |
Retourne cette instance de String ; aucune conversion n'est effectivement effectuée. |
| ToString(IFormatProvider) |
Retourne cette instance de String ; aucune conversion n'est effectivement effectuée. |
| ToUpper() |
Retourne une copie de cette chaîne convertie en majuscules. |
| ToUpper(CultureInfo) |
Retourne une copie de cette chaîne convertie en majuscules à l'aide des règles de casse de la culture spécifiée. |
| ToUpperInvariant() |
Retourne une copie de cet objet String converti en majuscules à l'aide des règles de casse de la culture indifférente. |
| Trim() |
Supprime tous les caractères correspondant à un espace blanc au début et à la fin de la chaîne actuelle. |
| Trim(Char) |
Supprime toutes les instances d’un caractère au début et à la fin de la chaîne actuelle. |
| Trim(Char[]) |
Supprime toutes les occurrences du jeu de caractères spécifié dans un tableau au début et à la fin de la chaîne actuelle. |
| TrimEnd() |
Supprime tous les caractères correspondant à un espace blanc à la fin de la chaîne actuelle. |
| TrimEnd(Char) |
Supprime toutes les occurrences d’un caractère à la fin de la chaîne actuelle. |
| TrimEnd(Char[]) |
Supprime toutes les occurrences du jeu de caractères spécifié dans un tableau à la fin de la chaîne actuelle. |
| TrimStart() |
Supprime tous les caractères correspondant à un espace blanc au début de la chaîne actuelle. |
| TrimStart(Char) |
Supprime toutes les occurrences d’un caractère spécifique au début de la chaîne actuelle. |
| TrimStart(Char[]) |
Supprime toutes les occurrences du jeu de caractères spécifié dans un tableau au début de la chaîne actuelle. |
| TryCopyTo(Span<Char>) |
Copie le contenu de cette chaîne dans l’étendue de destination. |
Opérateurs
| Equality(String, String) |
Détermine si deux chaînes spécifiées ont la même valeur. |
| Implicit(String to ReadOnlySpan<Char>) |
Définit une conversion implicite d’une chaîne donnée en une étendue de caractères en lecture seule. |
| Inequality(String, String) |
Détermine si deux chaînes spécifiées ont des valeurs différentes. |
Implémentations d’interfaces explicites
| IComparable.CompareTo(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é. |
| IConvertible.GetTypeCode() | |
| IConvertible.ToBoolean(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToBoolean(IFormatProvider). |
| IConvertible.ToByte(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToByte(IFormatProvider). |
| IConvertible.ToChar(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToChar(IFormatProvider). |
| IConvertible.ToDateTime(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToDateTime(IFormatProvider). |
| IConvertible.ToDecimal(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToDecimal(IFormatProvider). |
| IConvertible.ToDouble(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToDouble(IFormatProvider). |
| IConvertible.ToInt16(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToInt16(IFormatProvider). |
| IConvertible.ToInt32(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToInt32(IFormatProvider). |
| IConvertible.ToInt64(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToInt64(IFormatProvider). |
| IConvertible.ToSByte(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToSByte(IFormatProvider). |
| IConvertible.ToSingle(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToSingle(IFormatProvider). |
| IConvertible.ToString(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToString(IFormatProvider). |
| IConvertible.ToType(Type, IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToType(Type, IFormatProvider). |
| IConvertible.ToUInt16(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToUInt16(IFormatProvider). |
| IConvertible.ToUInt32(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToUInt32(IFormatProvider). |
| IConvertible.ToUInt64(IFormatProvider) |
Pour obtenir une description de ce membre, consultez ToUInt64(IFormatProvider). |
| IEnumerable.GetEnumerator() |
Retourne un énumérateur qui itère au sein de l'objet String actuel. |
| IEnumerable<Char>.GetEnumerator() |
Retourne un énumérateur qui itère au sein de l'objet String actuel. |
| IParsable<String>.Parse(String, IFormatProvider) |
Analyse une chaîne en une valeur. |
| IParsable<String>.TryParse(String, IFormatProvider, String) |
Représente le texte en tant que séquence d’unités de code UTF-16. |
| ISpanParsable<String>.Parse(ReadOnlySpan<Char>, IFormatProvider) |
Analyse une étendue de caractères dans une valeur. |
| ISpanParsable<String>.TryParse(ReadOnlySpan<Char>, IFormatProvider, String) |
Représente le texte en tant que séquence d’unités de code UTF-16. |
Méthodes d’extension
| ToFrozenDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Crée un FrozenDictionary<TKey,TValue> à partir d’une IEnumerable<T> fonction de sélecteur de clé en fonction de spécifiée. |
| ToFrozenDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) |
Crée un FrozenDictionary<TKey,TValue> à partir de IEnumerable<T> selon des fonctions de sélection de clé et de sélection d'élément spécifiées. |
| ToFrozenSet<T>(IEnumerable<T>, IEqualityComparer<T>) |
Crée un FrozenSet<T> avec les valeurs spécifiées. |
| ToImmutableArray<TSource>(IEnumerable<TSource>) |
Crée un tableau immuable à partir de la collection spécifiée. |
| ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Construit un dictionnaire immuable à partir de la collection d’éléments existante, en appliquant une fonction de transformation aux clés source. |
| ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Construit un dictionnaire immuable basé sur une transformation d’une séquence. |
| ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>) |
Énumère et transforme une séquence et produit un dictionnaire immuable de son contenu. |
| ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>) |
Énumère et transforme une séquence et produit un dictionnaire immuable de son contenu à l’aide du comparateur de clé spécifié. |
| ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>) |
Énumère et transforme une séquence et produit un dictionnaire immuable de son contenu à l’aide des comparateurs de clé et de valeur spécifiés. |
| ToImmutableHashSet<TSource>(IEnumerable<TSource>) |
Énumère une séquence et produit un ensemble immuable de hachage de son contenu. |
| ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) |
Énumère une séquence, produit un ensemble immuable de hachage de son contenu et utilise le comparateur d’égalité spécifié pour le type d’ensemble. |
| ToImmutableList<TSource>(IEnumerable<TSource>) |
Énumère une séquence et produit une liste immuable de son contenu. |
| ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>) |
Énumère et transforme une séquence et produit un dictionnaire trié immuable de son contenu. |
| ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>) |
Énumère et transforme une séquence et produit un dictionnaire trié immuable de son contenu à l’aide du comparateur de clé spécifié. |
| ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>) |
Énumère et transforme une séquence et produit un dictionnaire trié immuable de son contenu à l’aide des comparateurs de clé et de valeur spécifiés. |
| ToImmutableSortedSet<TSource>(IEnumerable<TSource>) |
Énumère une séquence et produit un ensemble trié immuable de son contenu. |
| ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>) |
Énumère une séquence, produit un ensemble trié immuable de son contenu et utilise le comparateur spécifié. |
| CopyToDataTable<T>(IEnumerable<T>) |
Retourne un DataTable qui contient des copies des objets DataRow, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique |
| CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) |
Copie les objets DataRow vers le DataTable spécifié, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique |
| CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) |
Copie les objets DataRow vers le DataTable spécifié, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique |
| Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>) |
Applique une fonction d'accumulation sur une séquence. |
| Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>) |
Applique une fonction d'accumulation sur une séquence. La valeur initiale spécifiée est utilisée comme valeur d'accumulation initiale. |
| Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>) |
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. |
| All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Détermine si tous les éléments d'une séquence satisfont à une condition. |
| Any<TSource>(IEnumerable<TSource>) |
Détermine si une séquence contient des éléments. |
| Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Détermine si des éléments d'une séquence satisfont à une condition. |
| Append<TSource>(IEnumerable<TSource>, TSource) |
Ajoute une valeur à la fin de la séquence. |
| AsEnumerable<TSource>(IEnumerable<TSource>) |
Retourne l’entrée typée comme IEnumerable<T>. |
| Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) |
Calcule la moyenne d'une séquence de valeurs Decimal obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. |
| Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>) |
Calcule la moyenne d'une séquence de valeurs Double obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. |
| Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) |
Calcule la moyenne d'une séquence de valeurs Int32 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. |
| Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) |
Calcule la moyenne d'une séquence de valeurs Int64 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. |
| Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) |
Calcule la moyenne d'une séquence de valeurs Decimal nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. |
| Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) |
Calcule la moyenne d'une séquence de valeurs Double nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. |
| Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) |
Calcule la moyenne d'une séquence de valeurs Int32 nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. |
| Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) |
Calcule la moyenne d'une séquence de valeurs Int64 nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. |
| Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) |
Calcule la moyenne d'une séquence de valeurs Single nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. |
| Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>) |
Calcule la moyenne d'une séquence de valeurs Single obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. |
| Cast<TResult>(IEnumerable) |
Effectue un cast des éléments d'un IEnumerable vers le type spécifié. |
| Chunk<TSource>(IEnumerable<TSource>, Int32) |
Fractionne les éléments d’une séquence en blocs de taille au maximum |
| Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Concatène deux séquences. |
| Contains<TSource>(IEnumerable<TSource>, TSource) |
Détermine si une séquence contient un élément spécifié à l'aide du comparateur d'égalité par défaut. |
| Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>) |
Détermine si une séquence contient un élément spécifié à l'aide du IEqualityComparer<T> indiqué. |
| Count<TSource>(IEnumerable<TSource>) |
Retourne le nombre total d'éléments dans une séquence. |
| Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Retourne un nombre qui représente les éléments de la séquence spécifiée qui satisfont à une condition. |
| DefaultIfEmpty<TSource>(IEnumerable<TSource>) |
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. |
| DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource) |
Retourne les éléments de la séquence spécifiée ou la valeur indiquée dans une collection de singletons si la séquence est vide. |
| Distinct<TSource>(IEnumerable<TSource>) |
Retourne des éléments distincts d'une séquence et utilise le comparateur d'égalité par défaut pour comparer les valeurs. |
| Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) |
Retourne des éléments distincts d'une séquence et utilise le IEqualityComparer<T> spécifié pour comparer les valeurs. |
| DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Retourne des éléments distincts d’une séquence en fonction d’une fonction de sélecteur de clé spécifiée. |
| DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Retourne des éléments distincts d’une séquence en fonction d’une fonction de sélecteur de clé spécifiée et à l’aide d’un comparateur spécifié pour comparer les clés. |
| ElementAt<TSource>(IEnumerable<TSource>, Index) |
Retourne l'élément à une position d'index spécifiée dans une séquence. |
| ElementAt<TSource>(IEnumerable<TSource>, Int32) |
Retourne l'élément à une position d'index spécifiée dans une séquence. |
| ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index) |
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. |
| ElementAtOrDefault<TSource>(IEnumerable<TSource>, 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. |
| Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Produit la différence entre deux séquences à l'aide du comparateur d'égalité par défaut pour comparer les valeurs. |
| Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) |
Produit la différence entre deux séquences à l'aide du IEqualityComparer<T> spécifié pour comparer les valeurs. |
| ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>) |
Produit la différence d’ensemble de deux séquences en fonction d’une fonction de sélecteur de clé spécifiée. |
| ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Produit la différence d’ensemble de deux séquences en fonction d’une fonction de sélecteur de clé spécifiée. |
| First<TSource>(IEnumerable<TSource>) |
Retourne le premier élément d'une séquence. |
| First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Retourne le premier élément d’une séquence à satisfaire à la condition spécifiée. |
| FirstOrDefault<TSource>(IEnumerable<TSource>) |
Retourne le premier élément d’une séquence ou une valeur par défaut si la séquence ne contient aucun élément. |
| FirstOrDefault<TSource>(IEnumerable<TSource>, TSource) |
Retourne le premier élément d’une séquence ou une valeur par défaut spécifiée si la séquence ne contient aucun élément. |
| FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
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é. |
| FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource) |
Retourne le premier élément de la séquence qui remplit une condition, ou une valeur par défaut spécifiée si aucun élément de ce type n’est trouvé. |
| GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée. |
| GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et compare les clés à l'aide du comparateur indiqué. |
| GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) |
Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et projette les éléments de chaque groupe à l'aide de la fonction indiquée. |
| GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) |
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. |
| GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>) |
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. |
| GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>) |
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é. |
| GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>) |
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. |
| GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>) |
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. |
| GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>) |
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. |
| GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>) |
Met en corrélation les éléments de deux séquences en fonction de l'égalité des clés et regroupe les résultats. Un IEqualityComparer<T> spécifié est utilisé pour comparer les clés. |
| Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Produit l'intersection de deux séquences à l'aide du comparateur d'égalité par défaut pour comparer les valeurs. |
| Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) |
Produit l'intersection entre deux séquences à l'aide du IEqualityComparer<T> spécifié pour comparer les valeurs. |
| IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>) |
Produit l’intersection définie de deux séquences en fonction d’une fonction de sélecteur de clé spécifiée. |
| IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Produit l’intersection définie de deux séquences en fonction d’une fonction de sélecteur de clé spécifiée. |
| Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>) |
Met en corrélation les éléments de deux séquences en fonction des clés qui correspondent. Le comparateur d'égalité par défaut est utilisé pour comparer les clés. |
| Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>) |
Met en corrélation les éléments de deux séquences en fonction des clés qui correspondent. Un IEqualityComparer<T> spécifié est utilisé pour comparer les clés. |
| Last<TSource>(IEnumerable<TSource>) |
Retourne le dernier élément d'une séquence. |
| Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Retourne le dernier élément d’une séquence à satisfaire à la condition spécifiée. |
| LastOrDefault<TSource>(IEnumerable<TSource>) |
Retourne le dernier élément d’une séquence ou une valeur par défaut si la séquence ne contient aucun élément. |
| LastOrDefault<TSource>(IEnumerable<TSource>, TSource) |
Retourne le dernier élément d’une séquence ou une valeur par défaut spécifiée si la séquence ne contient aucun élément. |
| LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
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é. |
| LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource) |
Retourne le dernier élément d’une séquence qui remplit une condition, ou une valeur par défaut spécifiée si aucun élément de ce type n’est trouvé. |
| LongCount<TSource>(IEnumerable<TSource>) |
Retourne un Int64 qui représente le nombre total d'éléments dans une séquence. |
| LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Retourne un Int64 qui représente le nombre total d'éléments dans une séquence à satisfaire à une condition. |
| Max<TSource>(IEnumerable<TSource>) |
Retourne la valeur maximale dans une séquence générique. |
| Max<TSource>(IEnumerable<TSource>, IComparer<TSource>) |
Retourne la valeur maximale dans une séquence générique. |
| Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) |
Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Decimal maximale. |
| Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>) |
Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Double maximale. |
| Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) |
Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int32 maximale. |
| Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) |
Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int64 maximale. |
| Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) |
Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Decimal nullable maximale. |
| Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) |
Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Double nullable maximale. |
| Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) |
Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int32 nullable maximale. |
| Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) |
Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int64 nullable maximale. |
| Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) |
Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Single nullable maximale. |
| Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>) |
Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Single maximale. |
| Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) |
Appelle une fonction de transformation sur chaque élément d'une séquence générique et retourne la valeur résultante maximale. |
| MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Retourne la valeur maximale dans une séquence générique en fonction d’une fonction de sélecteur de clé spécifiée. |
| MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) |
Retourne la valeur maximale dans une séquence générique en fonction d’une fonction de sélecteur de clé et d’un comparateur de clés spécifiés. |
| Min<TSource>(IEnumerable<TSource>) |
Retourne la valeur minimale dans une séquence générique. |
| Min<TSource>(IEnumerable<TSource>, IComparer<TSource>) |
Retourne la valeur minimale dans une séquence générique. |
| Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) |
Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Decimal minimale. |
| Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>) |
Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Double minimale. |
| Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) |
Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int32 minimale. |
| Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) |
Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int64 minimale. |
| Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) |
Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Decimal nullable minimale. |
| Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) |
Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Double nullable minimale. |
| Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) |
Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int32 nullable minimale. |
| Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) |
Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Int64 nullable minimale. |
| Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) |
Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Single nullable minimale. |
| Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>) |
Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur Single minimale. |
| Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) |
Appelle une fonction de transformation sur chaque élément d'une séquence générique et retourne la valeur résultante minimale. |
| MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Retourne la valeur minimale dans une séquence générique en fonction d’une fonction de sélecteur de clé spécifiée. |
| MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) |
Retourne la valeur minimale dans une séquence générique en fonction d’une fonction de sélecteur de clé et d’un comparateur de clés spécifiés. |
| OfType<TResult>(IEnumerable) |
Filtre les éléments d'un IEnumerable en fonction du type spécifié. |
| Order<T>(IEnumerable<T>) |
Trie les éléments d'une séquence dans l'ordre croissant. |
| Order<T>(IEnumerable<T>, IComparer<T>) |
Trie les éléments d'une séquence dans l'ordre croissant. |
| OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Trie les éléments d'une séquence dans l'ordre croissant selon une clé. |
| OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) |
Trie les éléments d'une séquence dans l'ordre croissant à l'aide d'un comparateur spécifié. |
| OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Trie les éléments d'une séquence dans l'ordre décroissant selon une clé. |
| OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>) |
Trie les éléments d'une séquence dans l'ordre décroissant à l'aide d'un comparateur spécifié. |
| OrderDescending<T>(IEnumerable<T>) |
Trie les éléments d'une séquence dans l'ordre décroissant. |
| OrderDescending<T>(IEnumerable<T>, IComparer<T>) |
Trie les éléments d'une séquence dans l'ordre décroissant. |
| Prepend<TSource>(IEnumerable<TSource>, TSource) |
Ajoute une valeur au début de la séquence. |
| Reverse<TSource>(IEnumerable<TSource>) |
Inverse l'ordre des éléments dans une séquence. |
| Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>) |
Projette chaque élément d’une séquence dans un nouveau formulaire. |
| Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>) |
Projette chaque élément d'une séquence dans un nouveau formulaire en incorporant l'index de l'élément. |
| SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>) |
Projette chaque élément d'une séquence sur un IEnumerable<T> et aplatit les séquences résultantes en une seule séquence. |
| SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>) |
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. |
| SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) |
Projette chaque élément d'une séquence sur un IEnumerable<T>, aplatit les séquences résultantes en une seule séquence et appelle une fonction de sélection de résultat sur chaque élément inclus. |
| SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>) |
Projette chaque élément d'une séquence sur un IEnumerable<T>, aplatit les séquences résultantes en une seule séquence et appelle une fonction de sélection de résultat sur chaque élément inclus. L'index de chaque élément source est utilisé dans le formulaire intermédiaire projeté de l'élément. |
| SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Détermine si deux séquences sont égales par une comparaison des types d'élément réalisée à l'aide du comparateur d'égalité par défaut. |
| SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) |
Détermine si deux séquences sont égales en comparant leurs éléments à l'aide d'un IEqualityComparer<T> spécifié. |
| Single<TSource>(IEnumerable<TSource>) |
Retourne l’élément unique d’une séquence ou lève une exception si cette séquence ne contient pas un seul élément. |
| Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
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. |
| SingleOrDefault<TSource>(IEnumerable<TSource>) |
Retourne l'élément unique d'une séquence ou une valeur par défaut. Cette méthode lève une exception si cette séquence contient plusieurs éléments. |
| SingleOrDefault<TSource>(IEnumerable<TSource>, TSource) |
Retourne le seul élément d’une séquence, ou une valeur par défaut spécifiée si la séquence est vide ; cette méthode lève une exception s’il existe plusieurs éléments dans la séquence. |
| SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
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. |
| SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource) |
Retourne le seul élément d’une séquence qui satisfait à une condition spécifiée, ou une valeur par défaut spécifiée si aucun élément de ce type n’existe ; cette méthode lève une exception si plusieurs éléments satisfont à la condition. |
| Skip<TSource>(IEnumerable<TSource>, Int32) |
Ignore un nombre spécifié d'éléments dans une séquence puis retourne les éléments restants. |
| SkipLast<TSource>(IEnumerable<TSource>, Int32) |
Retourne une nouvelle collection énumérable qui contient les éléments de |
| SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Ignore des éléments dans une séquence tant que la condition spécifiée a la valeur true, puis retourne les éléments restants. |
| SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>) |
Ignore des éléments dans une séquence tant que la condition spécifiée a la valeur true, puis retourne les éléments restants. L’index de l’élément est utilisé dans la logique de la fonction de prédicat. |
| Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>) |
Calcule la somme d'une séquence de valeurs Decimal obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. |
| Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>) |
Calcule la somme d'une séquence de valeurs Double obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. |
| Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>) |
Calcule la somme d'une séquence de valeurs Int32 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. |
| Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>) |
Calcule la somme d'une séquence de valeurs Int64 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. |
| Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>) |
Calcule la somme d'une séquence de valeurs Decimal nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. |
| Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>) |
Calcule la somme d'une séquence de valeurs Double nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. |
| Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>) |
Calcule la somme d'une séquence de valeurs Int32 nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. |
| Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>) |
Calcule la somme d'une séquence de valeurs Int64 nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. |
| Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>) |
Calcule la somme d'une séquence de valeurs Single nullables obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. |
| Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>) |
Calcule la somme d'une séquence de valeurs Single obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée. |
| Take<TSource>(IEnumerable<TSource>, Int32) |
Retourne un nombre spécifié d'éléments contigus à partir du début d'une séquence. |
| Take<TSource>(IEnumerable<TSource>, Range) |
Retourne une plage spécifiée d’éléments contigus d’une séquence. |
| TakeLast<TSource>(IEnumerable<TSource>, Int32) |
Retourne une nouvelle collection énumérable qui contient les derniers éléments |
| TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Retourne des éléments d'une séquence tant que la condition spécifiée a la valeur true. |
| TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>) |
Retourne des éléments d'une séquence tant que la condition spécifiée a la valeur true. L’index de l’élément est utilisé dans la logique de la fonction de prédicat. |
| ToArray<TSource>(IEnumerable<TSource>) |
Crée un tableau à partir de IEnumerable<T>. |
| ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Crée un Dictionary<TKey,TValue> à partir d'un IEnumerable<T> selon une fonction de sélection de clé spécifiée. |
| ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Crée un Dictionary<TKey,TValue> à partir de IEnumerable<T> selon une fonction de sélection de clé spécifiée et un comparateur de clé. |
| ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) |
Crée un Dictionary<TKey,TValue> à partir de IEnumerable<T> selon des fonctions de sélection de clé et de sélection d'élément spécifiées. |
| ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) |
Crée un Dictionary<TKey,TValue> à partir de IEnumerable<T> selon une fonction de sélection de clé spécifiée, un comparateur et une fonction de sélection d'élément. |
| ToHashSet<TSource>(IEnumerable<TSource>) |
Crée un HashSet<T> à partir d’un IEnumerable<T>. |
| ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>) |
Crée un HashSet<T> à partir d’un IEnumerable<T> en utilisant |
| ToList<TSource>(IEnumerable<TSource>) |
Crée un List<T> à partir d’un IEnumerable<T>. |
| ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) |
Crée un Lookup<TKey,TElement> à partir d'un IEnumerable<T> selon une fonction de sélection de clé spécifiée. |
| ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Crée un Lookup<TKey,TElement> à partir de IEnumerable<T> selon une fonction de sélection de clé spécifiée et un comparateur de clé. |
| ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>) |
Crée un Lookup<TKey,TElement> à partir de IEnumerable<T> selon des fonctions de sélection de clé et de sélection d'élément spécifiées. |
| ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>) |
Crée une Lookup<TKey,TElement> à partir de IEnumerable<T> selon une fonction de sélection de clé spécifiée, un comparateur et une fonction de sélection d'élément. |
| TryGetNonEnumeratedCount<TSource>(IEnumerable<TSource>, Int32) |
Tente de déterminer le nombre d’éléments d’une séquence sans forcer une énumération. |
| Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) |
Produit l'union de deux séquences à l'aide du comparateur d'égalité par défaut. |
| Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>) |
Produit l'union de deux séquences à l'aide d'un IEqualityComparer<T> spécifié. |
| UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>) |
Produit l’union définie de deux séquences en fonction d’une fonction de sélecteur de clé spécifiée. |
| UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>) |
Produit l’union définie de deux séquences en fonction d’une fonction de sélecteur de clé spécifiée. |
| Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>) |
Filtre une séquence de valeurs selon un prédicat. |
| Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>) |
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. |
| Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>) |
Produit une séquence de tuples avec des éléments des deux séquences spécifiées. |
| Zip<TFirst,TSecond,TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>) |
Produit une séquence de tuples avec des éléments des trois séquences spécifiées. |
| Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>) |
Applique une fonction spécifiée aux éléments correspondants de deux séquences pour produire une séquence des résultats. |
| AsParallel(IEnumerable) |
Active la parallélisation d'une requête. |
| AsParallel<TSource>(IEnumerable<TSource>) |
Active la parallélisation d'une requête. |
| AsQueryable(IEnumerable) |
Convertit un IEnumerable en IQueryable. |
| AsQueryable<TElement>(IEnumerable<TElement>) |
Convertit un IEnumerable<T> générique en IQueryable<T> générique. |
| AsMemory(String) |
Crée un |
| AsMemory(String, Index) |
Crée un |
| AsMemory(String, Int32) |
Crée un |
| AsMemory(String, Int32, Int32) |
Crée un |
| AsMemory(String, Range) |
Crée un |
| AsSpan(String) |
Crée une étendue en lecture seule sur une chaîne. |
| AsSpan(String, Index) |
Crée un sur ReadOnlySpan<T> une partie de la chaîne cible à partir d’une position spécifiée jusqu’à la fin de la chaîne. |
| AsSpan(String, Int32) |
Crée une étendue en lecture seule sur une partie de la chaîne cible à une position spécifiée jusqu’à la fin de la chaîne. |
| AsSpan(String, Int32, Int32) |
Crée une étendue en lecture seule sur une partie de la chaîne cible à une position spécifiée pour un nombre spécifié de caractères. |
| AsSpan(String, Range) |
Crée un nouveau ReadOnlySpan<T> sur une partie d’une chaîne cible à l’aide des index de début et de fin de plage. |
| IsNormalized(String) |
Indique si la chaîne spécifiée figure dans un formulaire de normalisation Unicode C. |
| IsNormalized(String, NormalizationForm) |
Indique si une chaîne figure dans un formulaire de normalisation Unicode spécifié. |
| Normalize(String) |
Normalise une chaîne en un formulaire de normalisation C Unicode. |
| Normalize(String, NormalizationForm) |
Normalise une chaîne au formulaire de normalisation Unicode spécifié. |
| Ancestors<T>(IEnumerable<T>) |
Retourne une collection d'éléments qui contient les ancêtres de chaque nœud de la collection source. |
| Ancestors<T>(IEnumerable<T>, XName) |
Retourne une collection d'éléments filtrée qui contient les ancêtres de chaque nœud de la collection source. Seuls les éléments avec un XName correspondant sont inclus dans la collection. |
| DescendantNodes<T>(IEnumerable<T>) |
Retourne une collection des nœuds descendants de chaque document et élément de la collection source. |
| Descendants<T>(IEnumerable<T>) |
Retourne une collection d'éléments qui contient les éléments descendants de tous les éléments et tous les documents de la collection source. |
| Descendants<T>(IEnumerable<T>, XName) |
Retourne une collection d'éléments filtrée qui contient les éléments descendants de tous les éléments et tous les documents de la collection source. Seuls les éléments avec un XName correspondant sont inclus dans la collection. |
| Elements<T>(IEnumerable<T>) |
Retourne une collection des éléments enfants de chaque élément et document de la collection source. |
| Elements<T>(IEnumerable<T>, XName) |
Retourne une collection filtrée des éléments enfants de chaque élément et document de la collection source. Seuls les éléments avec un XName correspondant sont inclus dans la collection. |
| InDocumentOrder<T>(IEnumerable<T>) |
Retourne une collection de nœuds qui contient tous les nœuds de la collection source, triés selon l'ordre des documents. |
| Nodes<T>(IEnumerable<T>) |
Retourne une collection des nœuds enfants de chaque document et élément de la collection source. |
| Remove<T>(IEnumerable<T>) |
Supprime chaque nœud de la collection source de son nœud parent. |
S’applique à
Cohérence de thread
Ce type est thread-safe.
Voir aussi
- IComparable
- ICloneable
- IConvertible
- IEnumerable
- StringBuilder
- CultureInfo
- Tri des tables de pondération pour Windows (.NET Framework et .NET Core uniquement)
- Tables d’éléments de classement Unicode par défaut
- Mettre en forme des types dans .NET
- Bonnes pratiques pour l’utilisation de chaînes dans .NET