Constructeur System.String

Article
01/31/2024

Cet article vous offre des remarques complémentaires à la documentation de référence pour cette API.

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 non sécurisé. 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 2 : utiliser un tableau de caractères).

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 3 : Utiliser une partie d’un tableau de caractères et répéter un caractère unique).

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 3 : utiliser une partie d’un tableau de caractères et répéter un seul caractère).

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 4 : Utiliser un pointeur vers un tableau de caractères).

Autorisation : SecurityCriticalAttribute, né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 du value début à l’index startIndex et se terminant à l’index startIndexlength + - 1 (Exemple 5 : instancier une chaîne à partir d’un pointeur et d’une plage d’un tableau).

Autorisation : SecurityCriticalAttribute, né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 à partir de value l’emplacement spécifié par le pointeur jusqu’à ce qu’un caractère null (0x00) soit atteint (exemple 6 : instancier une chaîne d’un pointeur vers un tableau d’octets signé).

Autorisation : SecurityCriticalAttribute, né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 à startIndexstartIndexlength + - 1 (Exemple 6 : instancier une chaîne d’un pointeur vers un tableau d’octets signé).

Autorisation : SecurityCriticalAttribute, né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 : SecurityCriticalAttribute, né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 connaître 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 de départ du `value` 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 connaître 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 null de caractères Unicode ou tableau d’entiers signés 8 bits. S’il `value` s’agit `null` ou 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 les constructeurs qui n’incluent pas de paramètres de pointeur.

Exception	Condition	Levée par
ArgumentNullException	`value` est `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 à 64 Ko. -ou- Impossible d’initialiser une nouvelle String instance à partir du `value` tableau d’octets, car `value` elle n’utilise pas l’encodage de page de codes 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	`valuevalue` + + `startIndexlength` ou - 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 1 : Utiliser l’attribution de chaîne)
Créez une chaîne à partir d’un tableau de caractères entier.	String(Char[]) (Exemple 2 : Utiliser un tableau de caractères)
Créez une chaîne à partir d’une partie d’un tableau de caractères.	String(Char[], Int32, Int32) (Exemple 3 : Utiliser une partie d’un tableau de caractères et répéter un seul caractère)
Créez une chaîne qui répète le même caractère plusieurs fois.	String(Char, Int32) (Exemple 3 : Utiliser une partie d’un tableau de caractères et répéter un seul caractère)
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 l’exemple 1. 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 en 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 startIndex vers l’index 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 qui ont 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 Gérer les 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 terminé par null, à l’aide du 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é plus startIndex et passe à la fin du tableau ou des length caractères. S’il value s’agit d’un pointeur Null ou length est égal à 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 length des 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 System;

public class Example2
{
   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 en tant que type [] managé ou non managéCharwchar_t[].

Si la String(Char*) surcharge est appelée et que le tableau n’est pas terminé 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 codes 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 - + value + startIndexlength1 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és en tant que 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 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(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 System;

public class Example5
{
   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 String(SByte*) constructeurs interprètent String(SByte*, Int32, Int32)value à l’aide de la page de codes ANSI par défaut, l’appel 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 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 constructeur, même si vous ne savez pas à l’avance quelles sont ces valeurs de chaîne identiques, vous pouvez utiliser une table de choix à la String(Char[], Int32, Int32) 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 reprises 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 nouvelle chaîne, vous pouvez créer un System.Xml.NameTable objet pour contenir des chaînes couramment présentes. 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 System;

public class Example3
{
   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
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 seul caractère

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 seul caractère.

// 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 String objet à partir d’un pointeur vers un tableau de caractères. L’exemple C# doit être compilé à l’aide du commutateur du /unsafe compilateur.

using System;

public class Example4
{
   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èdent 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 System;

public class Example1
{
   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.

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}"

Commentaires

Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.

Envoyer et afficher des commentaires pour

Ce produit Cette page

Afficher tous les commentaires de la page