String Constructeurs

Définition

Initialise une nouvelle instance de la classe String.

Surcharges

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[])

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(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(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*, 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, 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(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.

Remarques

Dans cette section :

Syntaxe du constructeur surchargé
Paramètres
Exceptions
Quelle méthode dois-je appeler ?
Création de chaînes
Gérer les chaînes répétitives

Exemples d’instanciation de chaînes :

Utiliser une attribution de chaîne
Utiliser un tableau de caractères
Utiliser une partie d’un tableau de caractères et répéter un seul caractère
Utiliser un pointeur vers un tableau de caractères
Utiliser un pointeur et une plage d’un tableau
Utiliser un pointeur vers un tableau d’octets signé

Syntaxe du constructeur surchargé

Les constructeurs de chaînes appartiennent à deux catégories : celles sans paramètres de pointeur et celles avec des paramètres de pointeur. Les constructeurs qui utilisent des pointeurs ne sont pas conformes CLS. En outre, Visual Basic ne prend pas en charge l’utilisation de pointeurs, et C# nécessite du code qui utilise des pointeurs pour s’exécuter dans un contexte dangereux. Pour plus d’informations, consultez unsafe.

Pour obtenir des conseils supplémentaires sur le choix d’une surcharge, consultez Quelle méthode dois-je appeler ?.

String(Char[] value)
Initialise la nouvelle instance à la valeur indiquée par un tableau de caractères Unicode. Ce constructeur copie les caractères Unicode (exemple).

String(Char[] value, Int32 startIndex, Int32 length)
Initialise la nouvelle instance à la valeur indiquée par un tableau de caractères Unicode, une position de caractère de départ dans ce tableau et une longueur (exemple).

String(Char c, Int32 count)
Initialise la nouvelle instance à la valeur indiquée par un caractère Unicode spécifié répété un nombre spécifié de fois (exemple).

String(char* value)
(Non conforme CLS) Initialise la nouvelle instance à la valeur indiquée par un pointeur vers un tableau de caractères Unicode qui se termine par un caractère Null (U+0000 ou '\0'). (exemple).

Autorisation : SecurityCriticalAttributenécessite une confiance totale pour l’appelant immédiat. Ce membre ne peut pas être utilisé par du code partiellement approuvé ou transparent.

String(char* value, Int32 startIndex, Int32 length)
(Non conforme CLS) Initialise la nouvelle instance à la valeur indiquée par un pointeur vers un tableau de caractères Unicode, une position de caractère de départ dans ce tableau et une longueur. Le constructeur copie les caractères Unicode à partir de l’index value startIndex et se terminant à l’indexlength startIndex + - 1 (exemple).

Autorisation : SecurityCriticalAttributenécessite une confiance totale pour l’appelant immédiat. Ce membre ne peut pas être utilisé par du code partiellement approuvé ou transparent.

String(SByte* value)
(Non conforme CLS) Initialise la nouvelle instance à la valeur indiquée par un pointeur vers un tableau d’entiers signés 8 bits. Le tableau est supposé représenter une chaîne encodée à l’aide de la page de codes système actuelle (autrement dit, l’encodage spécifié par Encoding.Default). Le constructeur traite les caractères à value partir de l’emplacement spécifié par le pointeur jusqu’à ce qu’un caractère Null (0x00) soit atteint (exemple).

Autorisation : SecurityCriticalAttributenécessite une confiance totale pour l’appelant immédiat. Ce membre ne peut pas être utilisé par du code partiellement approuvé ou transparent.

String(SByte* value, Int32 startIndex, Int32 length)
(Non conforme CLS) Initialise la nouvelle instance à la valeur indiquée par un pointeur vers un tableau d’entiers signés 8 bits, une position de départ dans ce tableau et une longueur. Le tableau est supposé représenter une chaîne encodée à l’aide de la page de codes système actuelle (autrement dit, l’encodage spécifié par Encoding.Default). Le constructeur traite les caractères de la valeur commençant à startIndex``length startIndex + - 1 (exemple).

Autorisation : SecurityCriticalAttributenécessite une confiance totale pour l’appelant immédiat. Ce membre ne peut pas être utilisé par du code partiellement approuvé ou transparent.

String(SByte* value, Int32 startIndex, Int32 length, Encoding enc)
(Non conforme CLS) Initialise la nouvelle instance à la valeur indiquée par un pointeur vers un tableau d’entiers signés 8 bits, une position de départ dans ce tableau, une longueur et un Encoding objet.

Autorisation : SecurityCriticalAttributenécessite une confiance totale pour l’appelant immédiat. Ce membre ne peut pas être utilisé par du code partiellement approuvé ou transparent.

Paramètres

Voici une liste complète des paramètres utilisés par String les constructeurs qui n’incluent pas de paramètre de pointeur. Pour les paramètres utilisés par chaque surcharge, consultez la syntaxe de surcharge ci-dessus.

Paramètre Type Description
value Char[] Tableau de caractères Unicode.
c Char Caractère Unicode.
startIndex Int32 Position value de départ du premier caractère dans la nouvelle chaîne.

Valeur par défaut : 0
length Int32 Nombre de caractères à value inclure dans la nouvelle chaîne.

Valeur par défaut : Array.Length
count Int32 Nombre de fois où le caractère c est répété dans la nouvelle chaîne. Si count la valeur est égale à zéro, la valeur du nouvel objet est String.Empty.

Voici une liste complète des paramètres utilisés par String les constructeurs qui incluent un paramètre de pointeur. Pour les paramètres utilisés par chaque surcharge, consultez la syntaxe de surcharge ci-dessus.

Paramètre Type Description
value Char*

- ou -

SByte*
Pointeur vers un tableau de caractères Unicode de type Null ou tableau d’entiers signés 8 bits. S’il s’agit value null d’un tableau vide, la valeur de la nouvelle chaîne est String.Empty.
startIndex Int32 Index de l’élément de tableau qui définit le premier caractère de la nouvelle chaîne.

Valeur par défaut : 0
length Int32 Nombre d’éléments de tableau à utiliser pour créer la nouvelle chaîne. Si la longueur est égale à zéro, le constructeur crée une chaîne dont la valeur est String.Empty.

Valeur par défaut : Array.Length
enc Encoding Objet qui spécifie la façon dont le value tableau est encodé.

Valeur par défaut : Encoding.Defaultou page de codes ANSI actuelle du système

Exceptions

Voici une liste d’exceptions levées par des constructeurs qui n’incluent pas de paramètres de pointeur.

Exception Condition Levée par
ArgumentNullException value a la valeur null. String(Char[], Int32, Int32)
ArgumentOutOfRangeException startIndex,length ou count est inférieur à zéro.

- ou -

La somme de startIndex et length est supérieure au nombre d’éléments de value.

- ou -

count est inférieur à zéro.
String(Char, Int32)

String(Char[], Int32, Int32)

Voici une liste d’exceptions levées par les constructeurs qui incluent des paramètres de pointeur.

Exception Condition Levée par
ArgumentException value spécifie un tableau qui contient un caractère Unicode non valide.

- ou -

value ou value + startIndex spécifie une adresse inférieure à 64K.

- ou -

Une nouvelle String instance n’a pas pu être initialisée à partir du value tableau d’octets, car value elle n’utilise pas l’encodage de page de code par défaut.
Tous les constructeurs avec des pointeurs.
ArgumentNullException value a la valeur null. String(SByte*)

String(SByte*, Int32, Int32)

String(SByte*, Int32, Int32, Encoding)
ArgumentOutOfRangeException Le processus actuel n’a pas d’accès en lecture à tous les caractères adressés.

- ou -

startIndex ou length est inférieur à zéro, value + startIndex entraîne un dépassement de capacité de pointeur ou le processus en cours n’a pas accès en lecture à tous les caractères identifiés par l’adresse.

- ou -

La longueur de la nouvelle chaîne est trop grande pour allouer.
Tous les constructeurs avec des pointeurs.
AccessViolationException valueou value + + startIndex``length - 1, spécifie une adresse non valide. String(SByte*)

String(SByte*, Int32, Int32)

String(SByte*, Int32, Int32, Encoding)

Quelle méthode dois-je appeler ?

À Appeler ou utiliser
Créez une chaîne. Affectation à partir d’un littéral de chaîne ou d’une chaîne existante (exemple)
Créez une chaîne à partir d’un tableau de caractères entier. String(Char[]) (exemple)
Créez une chaîne à partir d’une partie d’un tableau de caractères. String(Char[], Int32, Int32) (exemple)
Créez une chaîne qui répète le même caractère plusieurs fois. String(Char, Int32) (exemple)
Créez une chaîne à partir d’un pointeur vers un tableau de caractères Unicode ou large. String(Char*)
Créez une chaîne à partir d’une partie d’un tableau de caractères Unicode ou large à l’aide de son pointeur. String(Char*, Int32, Int32)
Créez une chaîne à partir d’un tableau C++ char . String(SByte*), String(SByte*, Int32, Int32)

- ou -

String(SByte*, Int32, Int32, Encoding)
Créez une chaîne à partir de caractères ASCII. ASCIIEncoding.GetString

Créer des chaînes

La technique la plus couramment utilisée pour créer des chaînes par programmation est une affectation simple, comme illustré dans cet exemple. La String classe inclut également quatre types de surcharges de constructeur qui vous permettent de créer des chaînes à partir des valeurs suivantes :

  • À partir d’un tableau de caractères (tableau de caractères codés UTF-16). Vous pouvez créer un String objet à partir des caractères de l’ensemble du tableau ou d’une partie de celui-ci. Le String(Char[]) constructeur copie tous les caractères du tableau dans la nouvelle chaîne. Le String(Char[], Int32, Int32) constructeur copie les caractères de l’index vers l’index + startIndex startIndex``length - 1 vers la nouvelle chaîne. Si length elle est égale à zéro, la valeur de la nouvelle chaîne est String.Empty.

    Si votre code instancie à plusieurs reprises des chaînes ayant la même valeur, vous pouvez améliorer les performances de l’application à l’aide d’un autre moyen de créer des chaînes. Pour plus d’informations, consultez Gestion des chaînes répétitives.

  • À partir d’un caractère unique qui est dupliqué zéro, un ou plusieurs fois, à l’aide du String(Char, Int32) constructeur. Si count elle est égale à zéro, la valeur de la nouvelle chaîne est String.Empty.

  • À partir d’un pointeur vers un tableau de caractères arrêté par null, à l’aide du constructeur ou String(Char*, Int32, Int32) du String(Char*) constructeur. Le tableau entier ou une plage spécifiée peut être utilisé pour initialiser la chaîne. Le constructeur copie une séquence de caractères Unicode à partir du pointeur spécifié ou du pointeur spécifié et startIndex continue à la fin du tableau ou des length caractères spécifiés. S’il value s’agit d’un pointeur null ou length de zéro, le constructeur crée une chaîne dont la valeur est String.Empty. Si l’opération de copie passe à la fin du tableau et que le tableau n’est pas terminé par null, le comportement du constructeur dépend du système. Une telle condition peut entraîner une violation d’accès.

    Si le tableau contient des caractères null incorporés (U+0000 ou '\0') et que la String(Char*, Int32, Int32) surcharge est appelée, l’instance de chaîne contient des length caractères incluant des valeurs Null incorporées. L’exemple suivant montre ce qui se passe lorsqu’un pointeur vers un tableau de 10 éléments incluant deux caractères null est passé à la String(Char*, Int32, Int32) méthode. Étant donné que l’adresse est le début du tableau et que tous les éléments du tableau doivent être ajoutés à la chaîne, le constructeur instancie une chaîne avec dix caractères, y compris deux valeurs Null incorporées. En revanche, si le même tableau est passé au String(Char*) constructeur, le résultat est une chaîne à quatre caractères qui n’inclut pas le premier caractère null.

    using namespace System;
    
    void main()
    {
       wchar_t chars[] = { L'a', L'b', L'c', L'd', L'\0', L'A', L'B', 
                           L'C', L'D', L'\0' };
       Char* chPtr = chars;
       String^ s = gcnew String(chPtr, 0, 
                                sizeof(chars) / sizeof (wchar_t));            
       for each (Char ch in s)
          Console::Write("{0:X4} ", Convert::ToUInt16(ch));
       Console::WriteLine();
       
       s = gcnew String(chPtr);         
       
       for each (Char ch in s)
          Console::Write("{0:X4} ", Convert::ToUInt16(ch));
       Console::WriteLine();    
    }
    // The example displays the following output:
    //       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
    //       0061 0062 0063 0064
    
    using System;
    
    public class Example
    {
       public unsafe static void Main()
       {
          char[] chars = { 'a', 'b', 'c', 'd', '\0', 'A', 'B', 'C', 'D', '\0' };
          string s = null;
          
          fixed(char* chPtr = chars) {
             s = new string(chPtr, 0, chars.Length);            
          } 
    
          foreach (var ch in s)
             Console.Write($"{(ushort)ch:X4} ");
          Console.WriteLine();
          
          fixed(char* chPtr = chars) {
             s = new string(chPtr);         
          }
          
          foreach (var ch in s)
             Console.Write($"{(ushort)ch:X4} ");
          Console.WriteLine();    
       }
    }
    // The example displays the following output:
    //       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
    //       0061 0062 0063 0064
    
    #nowarn "9"
    open System
    
    let chars = [| 'a'; 'b'; 'c'; 'd'; '\000'; 'A'; 'B'; 'C'; 'D'; '\000' |]
    let s =
        use chPtr = fixed chars
        String(chPtr, 0, chars.Length)
    
    for ch in s do
        printf $"{uint16 ch:X4} "
    printfn ""
    
    let s2 = 
        use chPtr = fixed chars
        String chPtr    
    
    for ch in s2 do
        printf $"{uint16 ch:X4} "
    printfn ""  
    // The example displays the following output:
    //       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
    //       0061 0062 0063 0064
    

    Le tableau doit contenir des caractères Unicode. En C++, cela signifie que le tableau de caractères doit être défini comme type managé Char[] ou comme type non managéwchar_t[] .

    Si la String(Char*) surcharge est appelée et que le tableau n’est pas arrêté par null, ou si la String(Char*, Int32, Int32) surcharge est appelée et startIndex + length-1 inclut une plage qui est en dehors de la mémoire allouée pour la séquence de caractères, le comportement du constructeur dépend du système et une violation d’accès peut se produire.

  • À partir d’un pointeur vers un tableau d’octets signé. Le tableau entier ou une plage spécifiée peut être utilisé pour initialiser la chaîne. La séquence d’octets peut être interprétée à l’aide de l’encodage de page de code par défaut, ou un encodage peut être spécifié dans l’appel du constructeur. Si le constructeur tente d’instancier une chaîne à partir d’un tableau entier qui n’est pas terminé par null ou si la plage du tableau de value``startIndex``startIndex``length + value + + -1 est en dehors de la mémoire allouée pour le tableau, le comportement de ce constructeur dépend du système et une violation d’accès peut se produire.

    Les trois constructeurs qui incluent un tableau d’octets signé comme paramètre sont conçus principalement pour convertir un tableau C++ char en chaîne, comme illustré dans cet exemple :

    using namespace System;
    
    void main()
    {
          char chars[] = { 'a', 'b', 'c', 'd', '\x00' };
          
          char* charPtr = chars;
          String^ value = gcnew String(charPtr);
    
          Console::WriteLine(value);
    }
    // The example displays the following output:
    //      abcd
    

    Si le tableau contient des caractères null ('\0') ou des octets dont la valeur est 0 et que la String(SByte*, Int32, Int32) surcharge est appelée, l’instance de chaîne contient length des caractères incluant des null incorporés. L’exemple suivant montre ce qui se passe lorsqu’un pointeur vers un tableau de 10 éléments incluant deux caractères null est passé à la String(SByte*, Int32, Int32) méthode. Étant donné que l’adresse est le début du tableau et que tous les éléments du tableau doivent être ajoutés à la chaîne, le constructeur instancie une chaîne avec dix caractères, y compris deux valeurs Null incorporées. En revanche, si le même tableau est passé au String(SByte*) constructeur, le résultat est une chaîne à quatre caractères qui n’inclut pas le premier caractère null.

    using namespace System;
    
    void main()
    {
       char bytes[] = { 0x61, 0x62, 0x063, 0x064, 0x00, 0x41, 0x42,0x43, 
                        0x44, 0x00 };
       
       char* bytePtr = bytes;
       String^ s = gcnew String(bytePtr, 0, sizeof(bytes) / sizeof (char));
       
       for each (Char ch in s)
          Console::Write("{0:X4} ", Convert::ToUInt16(ch));
       
       Console::WriteLine();
       
       s = gcnew String(bytePtr);
    
       for each (Char ch in s)
          Console::Write("{0:X4} ", Convert::ToUInt16(ch));
       Console::WriteLine();       
    }
    // The example displays the following output:
    //      0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
    //      0061 0062 0063 0064
    
    using System;
    
    public class Example
    {
       public unsafe static void Main()
       {
          sbyte[] bytes = { 0x61, 0x62, 0x063, 0x064, 0x00, 0x41, 0x42, 0x43, 0x44, 0x00 };
          
          string s = null;
          fixed (sbyte* bytePtr = bytes) {
             s = new string(bytePtr, 0, bytes.Length);
          }
          
          foreach (var ch in s)
             Console.Write($"{(ushort)ch:X4} ");
          
          Console.WriteLine();    
    
          fixed(sbyte* bytePtr = bytes) {
             s = new string(bytePtr);         
          }
          
          foreach (var ch in s)
             Console.Write($"{(ushort)ch:X4} ");
          Console.WriteLine();    
       }
    }
    // The example displays the following output:
    //       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
    //       0061 0062 0063 0064
    
    #nowarn "9"
    open System
    
    let bytes = 
        [| 0x61y; 0x62y; 0x063y; 0x064y; 0x00y; 0x41y; 0x42y; 0x43y; 0x44y; 0x00y |]
    
    let s =
        use bytePtr = fixed bytes
        String(bytePtr, 0, bytes.Length)
    
    for ch in s do
        printf $"{uint16 ch:X4} "
    printfn ""
    
    let s2 =
        use bytePtr = fixed bytes
        String bytePtr         
    
    for ch in s do
        printf $"{uint16 ch:X4} "
    printfn ""
    // The example displays the following output:
    //       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
    //       0061 0062 0063 0064
    

    Étant donné que les constructeurs interprètent String(SByte*, Int32, Int32) value à l’aide de la page de code ANSI par défaut, l’appel String(SByte*) de ces constructeurs avec des tableaux d’octets identiques peut créer des chaînes qui ont des valeurs différentes sur différents systèmes.

Gérer les chaînes répétitives

Les applications qui analysent ou décodent des flux de texte utilisent souvent le String(Char[], Int32, Int32) constructeur ou la StringBuilder.Append(Char[], Int32, Int32) méthode pour convertir des séquences de caractères en chaîne. La création répétée de nouvelles chaînes avec la même valeur au lieu de créer et de réutiliser une chaîne perd de la mémoire. Si vous êtes susceptible de créer la même valeur de chaîne à plusieurs reprises en appelant le String(Char[], Int32, Int32) constructeur, même si vous ne savez pas à l’avance ce que ces valeurs de chaîne identiques peuvent être, vous pouvez utiliser une table de recherche à la place.

Par exemple, supposons que vous lisez et analysez un flux de caractères à partir d’un fichier qui contient des balises et des attributs XML. Lorsque vous analysez le flux, vous rencontrez plusieurs fois certains jetons (c’est-à-dire des séquences de caractères qui ont une signification symbolique). Les jetons équivalents aux chaînes « 0 », « 1 », « true » et « false » sont susceptibles de se produire fréquemment dans un flux XML.

Au lieu de convertir chaque jeton en une nouvelle chaîne, vous pouvez créer un System.Xml.NameTable objet pour contenir des chaînes couramment survenues. L’objet NameTable améliore les performances, car il récupère des chaînes stockées sans allouer de mémoire temporaire. Lorsque vous rencontrez un jeton, utilisez la NameTable.Get(Char[], Int32, Int32) méthode pour récupérer le jeton à partir de la table. Si le jeton existe, la méthode retourne la chaîne correspondante. Si le jeton n’existe pas, utilisez la NameTable.Add(Char[], Int32, Int32) méthode pour insérer le jeton dans la table et obtenir la chaîne correspondante.

Exemple 1 : Utiliser l’attribution de chaîne

L’exemple suivant crée une chaîne en lui affectant un littéral de chaîne. Il crée une deuxième chaîne en lui affectant la valeur de la première chaîne. Il s’agit des deux méthodes les plus courantes pour instancier un nouvel String objet.

using namespace System;

void main()
{
   String^ value1 = L"This is a string.";
   String^ value2 = value1;
   Console::WriteLine(value1);
   Console::WriteLine(value2);
}
// The example displays the following output:
//    This is a string.
//    This is a string.
using System;

public class Example
{
   public static void Main()
   {
      String value1 = "This is a string.";
      String value2 = value1;
      Console.WriteLine(value1);
      Console.WriteLine(value2);
   }
}
// The example displays the following output:
//    This is a string.
//    This is a string.
let value1 = "This is a string."
let value2 = value1
printfn "%s" value1
printfn "%s" value2
// The example displays the following output:
//    This is a string.
//    This is a string.
Module Example
   Public Sub Main()
      Dim value1 As String = "This is a string."
      Dim value2 As String = value1
      Console.WriteLine(value1)
      Console.WriteLine(value2)
   End Sub
End Module
' The example displays the following output:
'    This is a string.
'    This is a string.

Exemple 2 : Utiliser un tableau de caractères

L’exemple suivant montre comment créer un String objet à partir d’un tableau de caractères.

// Unicode Mathematical operators
wchar_t charArray1[4] = {L'\x2200',L'\x2202',L'\x200F',L'\x2205'};
wchar_t * lptstr1 =  &charArray1[ 0 ];
String^ wszMathSymbols = gcnew String( lptstr1 );

// Unicode Letterlike Symbols
wchar_t charArray2[4] = {L'\x2111',L'\x2118',L'\x2122',L'\x2126'};
wchar_t * lptstr2 =  &charArray2[ 0 ];
String^ wszLetterLike = gcnew String( lptstr2 );

// Compare Strings - the result is false
Console::WriteLine( String::Concat( L"The Strings are equal? ", (0 == String::Compare( wszLetterLike, wszMathSymbols ) ? (String^)"TRUE" : "FALSE") ) );
// Unicode Mathematical operators
char [] charArr1 = {'\u2200','\u2202','\u200F','\u2205'};
String szMathSymbols = new String(charArr1);

// Unicode Letterlike Symbols
char [] charArr2 = {'\u2111','\u2118','\u2122','\u2126'};
String szLetterLike = new String (charArr2);

// Compare Strings - the result is false
Console.WriteLine("The Strings are equal? " +
    (String.Compare(szMathSymbols, szLetterLike)==0?"true":"false") );
// Unicode Mathematical operators
let charArr1 = [| '\u2200'; '\u2202'; '\u200F'; '\u2205' |]
let szMathSymbols = String charArr1

// Unicode Letterlike Symbols
let charArr2 = [| '\u2111'; '\u2118'; '\u2122'; '\u2126' |]
let szLetterLike = String charArr2

// Compare Strings - the result is false
printfn $"The Strings are equal? %b{String.Compare(szMathSymbols, szLetterLike) = 0}"
' Unicode Mathematical operators
Dim charArr1() As Char = {ChrW(&H2200), ChrW(&H2202), _
                          ChrW(&H200F), ChrW(&H2205)}
Dim szMathSymbols As New String(charArr1)

' Unicode Letterlike Symbols
Dim charArr2() As Char = {ChrW(&H2111), ChrW(&H2118), _
                          ChrW(&H2122), ChrW(&H2126)}
Dim szLetterLike As New String(charArr2)

' Compare Strings - the result is false
Console.WriteLine("The strings are equal? " & _
        CStr(szMathSymbols.Equals(szLetterLike)))

Exemple 3 : Utiliser une partie d’un tableau de caractères et répéter un caractère unique

L’exemple suivant montre comment créer un String objet à partir d’une partie d’un tableau de caractères et comment créer un String objet qui contient plusieurs occurrences d’un caractère unique.

// Create a Unicode String with 5 Greek Alpha characters
String^ szGreekAlpha = gcnew String( L'\x0391',5 );

// Create a Unicode String with a Greek Omega character
wchar_t charArray5[3] = {L'\x03A9',L'\x03A9',L'\x03A9'};
String^ szGreekOmega = gcnew String( charArray5,2,1 );
String^ szGreekLetters = String::Concat( szGreekOmega, szGreekAlpha, szGreekOmega->Clone() );

// Examine the result
Console::WriteLine( szGreekLetters );

// The first index of Alpha
int ialpha = szGreekLetters->IndexOf( L'\x0391' );

// The last index of Omega
int iomega = szGreekLetters->LastIndexOf( L'\x03A9' );
Console::WriteLine( String::Concat(  "The Greek letter Alpha first appears at index ", Convert::ToString( ialpha ) ) );
Console::WriteLine( String::Concat(  " and Omega last appears at index ", Convert::ToString( iomega ),  " in this String." ) );
// Create a Unicode String with 5 Greek Alpha characters
String szGreekAlpha = new String('\u0391',5);
// Create a Unicode String with a Greek Omega character
String szGreekOmega = new String(new char [] {'\u03A9','\u03A9','\u03A9'},2,1);

String szGreekLetters = String.Concat(szGreekOmega, szGreekAlpha, szGreekOmega.Clone());

// Examine the result
Console.WriteLine(szGreekLetters);

// The first index of Alpha
int ialpha = szGreekLetters.IndexOf('\u0391');
// The last index of Omega
int iomega = szGreekLetters.LastIndexOf('\u03A9');

Console.WriteLine("The Greek letter Alpha first appears at index " + ialpha +
    " and Omega last appears at index " + iomega + " in this String.");
// Create a Unicode String with 5 Greek Alpha characters
let szGreekAlpha = String('\u0391',5)
// Create a Unicode String with a Greek Omega character
let szGreekOmega = String([| '\u03A9'; '\u03A9'; '\u03A9' |],2,1)

let szGreekLetters = String.Concat(szGreekOmega, szGreekAlpha, szGreekOmega.Clone())

// Examine the result
printfn $"{szGreekLetters}"

// The first index of Alpha
let ialpha = szGreekLetters.IndexOf '\u0391'
// The last index of Omega
let iomega = szGreekLetters.LastIndexOf '\u03A9'

printfn $"The Greek letter Alpha first appears at index {ialpha} and Omega last appears at index {iomega} in this String."
' Create a Unicode String with 5 Greek Alpha characters
Dim szGreekAlpha As New String(ChrW(&H0391), 5)
' Create a Unicode String with a Greek Omega character
Dim szGreekOmega As New String(New Char() {ChrW(&H03A9), ChrW(&H03A9), _
                                           ChrW(&H03A9)}, 2, 1)

Dim szGreekLetters As String = String.Concat(szGreekOmega, szGreekAlpha, _
                                             szGreekOmega.Clone())

' Examine the result
Console.WriteLine(szGreekLetters)

' The first index of Alpha
Dim iAlpha As Integer = szGreekLetters.IndexOf(ChrW(&H0391))
' The last index of Omega
Dim iomega As Integer = szGreekLetters.LastIndexOf(ChrW(&H03A9))

Console.WriteLine("The Greek letter Alpha first appears at index {0}.", _ 
                  ialpha)
Console.WriteLIne("The Greek letter Omega last appears at index {0}.", _
                  iomega)

Exemple 4 : Utiliser un pointeur vers un tableau de caractères

L’exemple suivant montre comment créer un objet à String partir d’un pointeur vers un tableau de caractères. L’exemple C# doit être compilé à l’aide du commutateur du /unsafe compilateur.

using namespace System;

void main()
{
   wchar_t characters[] = {L'H',L'e',L'l',L'l',L'o',L' ', 
                           L'W',L'o',L'r',L'l',L'd',L'!',L'\x0000'};

   Char* charPtr = characters;
   String^ value = gcnew String(charPtr);
   Console::WriteLine(value);
}
// The example displays the following output:
//        Hello world!
using System;

public class Example
{
   public static unsafe void Main()
   {
      char[] characters = { 'H', 'e', 'l', 'l', 'o', ' ', 
                            'w', 'o', 'r', 'l', 'd', '!', '\u0000' };
      string value;
      
      fixed (char* charPtr = characters) {
         value = new String(charPtr);
      }                            
      Console.WriteLine(value);
   }
}
// The example displays the following output:
//        Hello world!
#nowarn "9"
open System

let characters = 
    [| 'H'; 'e'; 'l'; 'l'; 'o'; ' ' 
       'w'; 'o'; 'r'; 'l'; 'd'; '!'; '\u0000' |]

let value =
    use charPtr = fixed characters
    String charPtr

printfn $"{value}"
// The example displays the following output:
//        Hello world!

Exemple 5 : instancier une chaîne à partir d’un pointeur et d’une plage d’un tableau

L’exemple suivant examine les éléments d’un tableau de caractères pour un point d’exclamation ou un point d’exclamation. Si l’un d’eux est trouvé, il instancie une chaîne à partir des caractères du tableau qui précède le symbole de ponctuation. Si ce n’est pas le cas, il instancie une chaîne avec l’intégralité du contenu du tableau. L’exemple C# doit être compilé à l’aide du commutateur du /unsafe compilateur.

using namespace System;


void main()
{
   wchar_t characters[] = {L'H',L'e',L'l',L'l',L'o',L' ', 
                           L'W',L'o',L'r',L'l',L'd',L'!',L'\x0000'};

   Char* charPtr = characters;
   int length = 0;
   Char* iterator = charPtr;

   while (*iterator != '\x0000')
   {
      if (*iterator == L'!' || *iterator == L'.')
         break;
      *iterator++;
      length++;
   }
   String^ value = gcnew String(charPtr, 0, length);
   Console::WriteLine(value);
}
// The example displays the following output:
//      Hello World
using System;

public class Example
{
   public static unsafe void Main()
   {
      char[] characters = { 'H', 'e', 'l', 'l', 'o', ' ', 
                            'w', 'o', 'r', 'l', 'd', '!', '\u0000' };
      String value;
      
      fixed (char* charPtr = characters) {
         int length = 0;
         Char* iterator = charPtr;
   
         while (*iterator != '\x0000')
         {
            if (*iterator == '!' || *iterator == '.')
               break;
            iterator++;
            length++;
         }
         value = new String(charPtr, 0, length);
      }
      Console.WriteLine(value);
   }
}
// The example displays the following output:
//      Hello World
#nowarn "9"
open System
open FSharp.NativeInterop

let characters = 
    [| 'H'; 'e'; 'l'; 'l'; 'o'; ' '
       'w'; 'o'; 'r'; 'l'; 'd'; '!'; '\u0000' |]

[<EntryPoint>]
let main _ =
    use charPtr = fixed characters
    let mutable length = 0
    let mutable iterator = charPtr
    let mutable broken = false
    while not broken && NativePtr.read iterator <> '\u0000' do
        if NativePtr.read iterator = '!' || NativePtr.read iterator = '.' then
            broken <- true
        else
            iterator <- NativePtr.add iterator 1
            length <- length + 1
    String(charPtr, 0, length)
    |> printfn "%s"
    0
// The example displays the following output:
//      Hello World

Exemple 6 : instancier une chaîne d’un pointeur vers un tableau d’octets signé

L’exemple suivant montre comment créer une instance de la String classe avec le String(SByte*) constructeur.

// Null terminated ASCII characters in a simple char array
char charArray3[4] = {0x41,0x42,0x43,0x00};
char * pstr3 =  &charArray3[ 0 ];
String^ szAsciiUpper = gcnew String( pstr3 );
char charArray4[4] = {0x61,0x62,0x63,0x00};
char * pstr4 =  &charArray4[ 0 ];
String^ szAsciiLower = gcnew String( pstr4,0,sizeof(charArray4) );

// Prints "ABC abc"
Console::WriteLine( String::Concat( szAsciiUpper,  " ", szAsciiLower ) );

// Compare Strings - the result is true
Console::WriteLine( String::Concat(  "The Strings are equal when capitalized ? ", (0 == String::Compare( szAsciiUpper->ToUpper(), szAsciiLower->ToUpper() ) ? (String^)"TRUE" :  "FALSE") ) );

// This is the effective equivalent of another Compare method, which ignores case
Console::WriteLine( String::Concat(  "The Strings are equal when capitalized ? ", (0 == String::Compare( szAsciiUpper, szAsciiLower, true ) ? (String^)"TRUE" :  "FALSE") ) );
unsafe
{
    // Null terminated ASCII characters in an sbyte array
    String szAsciiUpper = null;
    sbyte[] sbArr1 = new sbyte[] { 0x41, 0x42, 0x43, 0x00 };
    // Instruct the Garbage Collector not to move the memory
    fixed(sbyte* pAsciiUpper = sbArr1)
    {
        szAsciiUpper = new String(pAsciiUpper);
    }
    String szAsciiLower = null;
    sbyte[] sbArr2 = { 0x61, 0x62, 0x63, 0x00 };
    // Instruct the Garbage Collector not to move the memory
    fixed(sbyte* pAsciiLower = sbArr2)
    {
        szAsciiLower = new String(pAsciiLower, 0, sbArr2.Length);
    }
    // Prints "ABC abc"
    Console.WriteLine(szAsciiUpper + " " + szAsciiLower);

    // Compare Strings - the result is true
    Console.WriteLine("The Strings are equal when capitalized ? " +
        (String.Compare(szAsciiUpper.ToUpper(), szAsciiLower.ToUpper())==0?"true":"false") );

    // This is the effective equivalent of another Compare method, which ignores case
    Console.WriteLine("The Strings are equal when capitalized ? " +
        (String.Compare(szAsciiUpper, szAsciiLower, true)==0?"true":"false") );
}
// Null terminated ASCII characters in an sbyte array
let szAsciiUpper =
    let sbArr1 = [| 0x41y; 0x42y; 0x43y; 0x00y |]
    // Instruct the Garbage Collector not to move the memory
    use pAsciiUpper = fixed sbArr1
    String pAsciiUpper

let szAsciiLower =
    let sbArr2 = [| 0x61y; 0x62y; 0x63y; 0x00y |]
    // Instruct the Garbage Collector not to move the memory
    use pAsciiLower = fixed sbArr2 
    String(pAsciiLower, 0, sbArr2.Length)

// Prints "ABC abc"
printfn $"{szAsciiUpper} {szAsciiLower}"

// Compare Strings - the result is true
printfn $"The Strings are equal when capitalized ? %b{String.Compare(szAsciiUpper.ToUpper(), szAsciiLower.ToUpper()) = 0}"

// This is the effective equivalent of another Compare method, which ignores case
printfn $"The Strings are equal when capitalized ? %b{String.Compare(szAsciiUpper, szAsciiLower, true) = 0}"

String(Char*)

Important

Cette API n’est pas conforme CLS.

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

public:
 String(char* value);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public String (char* value);
[System.CLSCompliant(false)]
public String (char* value);
[<System.CLSCompliant(false)>]
[<System.Security.SecurityCritical>]
new string : nativeptr<char> -> string
[<System.CLSCompliant(false)>]
new string : nativeptr<char> -> string

Paramètres

value
Char*

Pointeur vers un tableau de caractères Unicode terminé par un caractère null.

Attributs

Exceptions

Le processus actuel n’a pas d’accès en lecture à tous les caractères adressés.

value spécifie un tableau qui contient un caractère Unicode non valide ou value spécifie une adresse inférieure à 64000.

Remarques

Notes

Pour obtenir des exemples et des informations complètes sur l’utilisation de ce constructeur et d’autres String surcharges de constructeur, consultez le résumé du String constructeur.

S’applique à

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

public:
 String(cli::array <char> ^ value);
public String (char[] value);
public String (char[]? value);
new string : char[] -> string
Public Sub New (value As Char())

Paramètres

value
Char[]

Tableau de caractères Unicode.

Remarques

Notes

Pour obtenir des exemples et des informations d’utilisation complètes sur ces surcharges de constructeur et d’autres String constructeurs, consultez le résumé du String constructeur.

S’applique à

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.

public:
 String(ReadOnlySpan<char> value);
public String (ReadOnlySpan<char> value);
new string : ReadOnlySpan<char> -> string
Public Sub New (value As ReadOnlySpan(Of Char))

Paramètres

value
ReadOnlySpan<Char>

Étendue de caractères Unicode en lecture seule.

S’applique à

String(SByte*)

Important

Cette API n’est pas conforme CLS.

Initialise une nouvelle instance de la classe String à la valeur indiquée par un pointeur vers un tableau d'entiers signés 8 bits.

public:
 String(System::SByte* value);
[System.CLSCompliant(false)]
public String (sbyte* value);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public String (sbyte* value);
[<System.CLSCompliant(false)>]
new string : nativeptr<sbyte> -> string
[<System.CLSCompliant(false)>]
[<System.Security.SecurityCritical>]
new string : nativeptr<sbyte> -> string

Paramètres

value
SByte*

Pointeur vers un tableau d'entiers signés 8 bits terminé par le caractère null. Les entiers sont interprétés à l’aide de l’encodage de page de codes système actuel (autrement dit, l’encodage spécifié par Default).

Attributs

Exceptions

value a la valeur null.

Une nouvelle instance de String n’a pas pu être initialisée à l’aide de value, en supposant que value est encodé au format ANSI.

La longueur de la nouvelle chaîne à initialiser, déterminée par le caractère de fin Null de value, est trop grande à allouer.

value spécifie une adresse non valide.

Remarques

Notes

Pour obtenir des exemples et des informations d’utilisation complètes sur ces surcharges de constructeur et d’autres String constructeurs, consultez le résumé du String constructeur.

S’applique à

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.

public:
 String(char c, int count);
public String (char c, int count);
new string : char * int -> string
Public Sub New (c As Char, count As Integer)

Paramètres

c
Char

Caractère Unicode.

count
Int32

Nombre d'occurrences de c.

Exceptions

count est inférieur à zéro.

Remarques

Notes

Pour obtenir des exemples et des informations d’utilisation complètes sur ces surcharges de constructeur et d’autres String constructeurs, consultez le résumé du String constructeur.

S’applique à

String(Char*, Int32, Int32)

Important

Cette API n’est pas conforme CLS.

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.

public:
 String(char* value, int startIndex, int length);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public String (char* value, int startIndex, int length);
[System.CLSCompliant(false)]
public String (char* value, int startIndex, int length);
[<System.CLSCompliant(false)>]
[<System.Security.SecurityCritical>]
new string : nativeptr<char> * int * int -> string
[<System.CLSCompliant(false)>]
new string : nativeptr<char> * int * int -> string

Paramètres

value
Char*

Pointeur vers un tableau de caractères Unicode.

startIndex
Int32

Position de départ dans value.

length
Int32

Nombre de caractères dans value à utiliser.

Attributs

Exceptions

startIndex ou length est inférieur à zéro, value + startIndex entraîne un dépassement de capacité de pointeur ou le processus en cours n’a pas accès en lecture à tous les caractères identifiés par l’adresse.

value spécifie un tableau qui contient un caractère Unicode non valide ou value + startIndex spécifie une adresse inférieure à 64000.

Remarques

Notes

Pour obtenir des exemples et des informations d’utilisation complètes sur ces surcharges de constructeur et d’autres String constructeurs, consultez le résumé du String constructeur.

S’applique à

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.

public:
 String(cli::array <char> ^ value, int startIndex, int length);
public String (char[] value, int startIndex, int length);
new string : char[] * int * int -> string
Public Sub New (value As Char(), startIndex As Integer, length As Integer)

Paramètres

value
Char[]

Tableau de caractères Unicode.

startIndex
Int32

Position de départ dans value.

length
Int32

Nombre de caractères dans value à utiliser.

Exceptions

value a la valeur null.

startIndex ou length est inférieur à zéro.

  • ou -

La somme de startIndex et length est supérieure au nombre d’éléments de value.

Remarques

Notes

Pour obtenir des exemples et des informations d’utilisation complètes sur ces surcharges de constructeur et d’autres String constructeurs, consultez le résumé du String constructeur.

S’applique à

String(SByte*, Int32, Int32)

Important

Cette API n’est pas conforme CLS.

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.

public:
 String(System::SByte* value, int startIndex, int length);
[System.CLSCompliant(false)]
public String (sbyte* value, int startIndex, int length);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public String (sbyte* value, int startIndex, int length);
[<System.CLSCompliant(false)>]
new string : nativeptr<sbyte> * int * int -> string
[<System.CLSCompliant(false)>]
[<System.Security.SecurityCritical>]
new string : nativeptr<sbyte> * int * int -> string

Paramètres

value
SByte*

Pointeur vers un tableau d'entiers signés 8 bits. Les entiers sont interprétés à l’aide de l’encodage de page de codes système actuel (autrement dit, l’encodage spécifié par Default).

startIndex
Int32

Position de départ dans value.

length
Int32

Nombre de caractères dans value à utiliser.

Attributs

Exceptions

value a la valeur null.

startIndex ou length est inférieur à zéro.

  • ou -

L’adresse spécifiée par value + startIndex est trop grande pour la plateforme actuelle ; autrement dit, le calcul d’adresse a été l’objet d’un dépassement de capacité.

  • ou -

La longueur de la nouvelle chaîne à initialiser est trop grande à allouer.

L’adresse spécifiée par value + startIndex est inférieure à 64 Ko.

  • ou -

Une nouvelle instance de String n’a pas pu être initialisée à l’aide de value, en supposant que value est encodé au format ANSI.

value, startIndex et length spécifient collectivement une adresse non valide.

Remarques

Notes

Pour obtenir des exemples et des informations d’utilisation complètes sur ces surcharges de constructeur et d’autres String constructeurs, consultez le résumé du String constructeur.

S’applique à

String(SByte*, Int32, Int32, Encoding)

Important

Cette API n’est pas conforme CLS.

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.

public:
 String(System::SByte* value, int startIndex, int length, System::Text::Encoding ^ enc);
[System.CLSCompliant(false)]
public String (sbyte* value, int startIndex, int length, System.Text.Encoding enc);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public String (sbyte* value, int startIndex, int length, System.Text.Encoding enc);
[<System.CLSCompliant(false)>]
new string : nativeptr<sbyte> * int * int * System.Text.Encoding -> string
[<System.CLSCompliant(false)>]
[<System.Security.SecurityCritical>]
new string : nativeptr<sbyte> * int * int * System.Text.Encoding -> string

Paramètres

value
SByte*

Pointeur vers un tableau d'entiers signés 8 bits.

startIndex
Int32

Position de départ dans value.

length
Int32

Nombre de caractères dans value à utiliser.

enc
Encoding

Objet qui spécifie la façon dont le tableau référencé par value est encodé. Si enc est null, l'encodage ANSI est utilisé par défaut.

Attributs

Exceptions

value a la valeur null.

startIndex ou length est inférieur à zéro.

  • ou -

L’adresse spécifiée par value + startIndex est trop grande pour la plateforme actuelle ; autrement dit, le calcul d’adresse a été l’objet d’un dépassement de capacité.

  • ou -

La longueur de la nouvelle chaîne à initialiser est trop grande à allouer.

L’adresse spécifiée par value + startIndex est inférieure à 64 Ko.

  • ou -

Nous n’avons pas pu initialiser une nouvelle instance de String à l’aide de value, en supposant que value est encodé comme indiqué par enc.

value, startIndex et length spécifient collectivement une adresse non valide.

Remarques

Notes

Pour obtenir des exemples et des informations d’utilisation complètes sur ces surcharges de constructeur et d’autres String constructeurs, consultez le résumé du String constructeur.

S’applique à