String Constructeurs

Définition

Initialise une nouvelle instance de la classe String.Initializes a new instance of the String class.

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.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters.

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é.Initializes a new instance of the String class to the Unicode characters indicated in the specified character array.

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.Initializes a new instance of the String class to the Unicode characters indicated in the specified read-only span.

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.Initializes a new instance of the String class to the value indicated by a pointer to an array of 8-bit signed integers.

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.Initializes a new instance of the String class to the value indicated by a specified Unicode character repeated a specified number of times.

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.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters, a starting character position within that array, and a length.

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.Initializes a new instance of the String class to the value indicated by an array of Unicode characters, a starting character position within that array, and a length.

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.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, and a length.

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.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, a length, and an Encoding object.

Remarques

Dans cette section :In this section:

Syntaxe de constructeur surchargé Overloaded constructor syntax
Paramètres Parameters
Exceptions Exceptions
Quelle méthode appelle-t-elle ? Which method do I call?
Création de chaînes Creating strings
Gestion des chaînes répétitives Handling repetitive strings
Exemples d’instanciation de chaînes :Examples of instantiating strings:
Utilisation de l’assignation de chaîneUsing string assignment
Utilisation d’un tableau de caractèresUsing a character array
Utilisation d’une partie d’un tableau de caractères et répétition d’un caractère uniqueUsing a portion of a character array and repeating a single character
Utilisation d’un pointeur vers un tableau de caractèresUsing a pointer to a character array
Utilisation d’un pointeur et d’une plage d’un tableauUsing a pointer and a range of an array
Utilisation d’un pointeur vers un tableau d’octets signéUsing a pointer to a signed byte array
Informations sur la versionVersion information

Syntaxe de constructeur surchargéOverloaded constructor syntax

Les constructeurs de chaîne se répartissent en deux catégories : celles sans paramètres de pointeur, et celles avec des paramètres de pointeur.String constructors fall into two categories: those without pointer parameters, and those with pointer parameters. Les constructeurs qui utilisent des pointeurs ne sont pas conformes CLS.The constructors that use pointers are not CLS-compliant. En outre, Visual Basic ne prend pas en charge l’utilisation de pointeurs C# et requiert du code qui utilise des pointeurs pour s’exécuter dans un contexte non sécurisé.In addition, Visual Basic does not support the use of pointers, and C# requires code that uses pointers to run in an unsafe context. Pour plus d’informations, consultez unsafe.For more information, see unsafe.

Pour obtenir des conseils supplémentaires sur le choix d’une surcharge, consultez quelle méthode appelle-t-elle ?For additional guidance on choosing an overload, see Which method do I call?

String(Char[] value)
Initialise la nouvelle instance à la valeur indiquée par un tableau de caractères Unicode.Initializes the new instance to the value indicated by an array of Unicode characters. Ce constructeur copie les caractères Unicode (par exemple).This constructor copies Unicode characters(example).

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 départ de caractère dans ce tableau et une longueur (exemple).Initializes the new instance to the value indicated by an array of Unicode characters, a starting character position within that array, and a length (example).

String(Char c, Int32 count)
Initialise la nouvelle instance de à la valeur indiquée par un caractère Unicode spécifié, répété un nombre spécifié de fois (par exemple).Initializes the new instance to the value indicated by a specified Unicode character repeated a specified number of times (example).

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 ').(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of Unicode characters that is terminated by a null character (U+0000 or '\0'). (exemple).(example).

Autorisation : SecurityCriticalAttribute, requiert une confiance totale pour l’appelant immédiat.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Ce membre ne peut pas être utilisé par du code de confiance partielle ou transparent.This member cannot be used by partially trusted or transparent code.

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 début de caractère dans ce tableau et une longueur.(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of Unicode characters, a starting character position within that array, and a length. Le constructeur copie les caractères Unicode de value commençant à l’index startIndex et se termine à l’index startIndex + length-1 (exemple).The constructor copies the Unicode characters from value starting at index startIndex and ending at index startIndex + length - 1 (example).

Autorisation : SecurityCriticalAttribute, requiert une confiance totale pour l’appelant immédiat.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Ce membre ne peut pas être utilisé par du code de confiance partielle ou transparent.This member cannot be used by partially trusted or transparent code.

String(SByte* value)
(Non conforme CLS) Initialise la nouvelle instance de à la valeur indiquée par un pointeur vers un tableau d’entiers signés 8 bits.(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of 8-bit signed integers. 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).The array is assumed to represent a string encoded using the current system code page (that is, the encoding specified by Encoding.Default). Le constructeur traite les caractères de value à partir de l’emplacement spécifié par le pointeur jusqu’à ce qu’un caractère null (0x00) soit atteint (exemple).The constructor processes characters from value starting from the location specified by the pointer until a null character (0x00) is reached (example).

Autorisation : SecurityCriticalAttribute, requiert une confiance totale pour l’appelant immédiat.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Ce membre ne peut pas être utilisé par du code de confiance partielle ou transparent.This member cannot be used by partially trusted or transparent code.

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.(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of 8-bit signed integers, a starting position within that array, and a length. 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).The array is assumed to represent a string encoded using the current system code page (that is, the encoding specified by Encoding.Default). Le constructeur traite les caractères de la valeur à partir de startIndex et se termine à startIndex + length-1 (exemple).The constructor processes characters from value starting at startIndex and ending at startIndex + length - 1 (example).

Autorisation : SecurityCriticalAttribute, requiert une confiance totale pour l’appelant immédiat.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Ce membre ne peut pas être utilisé par du code de confiance partielle ou transparent.This member cannot be used by partially trusted or transparent code.

String(SByte* value, Int32 startIndex, Int32 length, Encoding enc)
(Non conforme CLS) Initialise la nouvelle instance de 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 objet Encoding.(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of 8-bit signed integers, a starting position within that array, a length, and an Encoding object.

Autorisation : SecurityCriticalAttribute, requiert une confiance totale pour l’appelant immédiat.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Ce membre ne peut pas être utilisé par du code de confiance partielle ou transparent.This member cannot be used by partially trusted or transparent code.

ParamètresParameters

Voici une liste complète des paramètres utilisés par les constructeurs String qui n’incluent pas de paramètre de pointeur.Here is a complete list of parameters used by String constructors that don't include a pointer parameter. Pour connaître les paramètres utilisés par chaque surcharge, consultez la syntaxe de surcharge ci-dessus.For the parameters used by each overload, see the overload syntax above.

ParamètreParameter TypeType DescriptionDescription
value Char[]Char[] Tableau de caractères Unicode.An array of Unicode characters.
c Char Caractère Unicode.A Unicode character.
startIndex Int32 Position de départ dans value du premier caractère de la nouvelle chaîne.The starting position in value of the first character in the new string.

Valeur par défaut : 0Default value: 0
length Int32 Nombre de caractères dans value à inclure dans la nouvelle chaîne.The number of characters in value to include in the new string.

Valeur par défaut : Array.LengthDefault value: Array.Length
count Int32 Nombre de fois où le caractère c est répété dans la nouvelle chaîne.The number of times the character c is repeated in the new string. Si count est égal à zéro, la valeur du nouvel objet est String.Empty.If count is zero, the value of the new object is String.Empty.

Voici une liste complète des paramètres utilisés par String constructeurs qui incluent un paramètre de pointeur.Here is a complete list of parameters used by String constructors that include a pointer parameter. Pour connaître les paramètres utilisés par chaque surcharge, consultez la syntaxe de surcharge ci-dessus.For the parameters used by each overload, see the overload syntax above.

ParamètreParameter TypeType DescriptionDescription
value Char*

- ou --or-

SByte*
Pointeur vers un tableau de caractères Unicode se terminant par un caractère null ou un tableau d’entiers signés 8 bits.A pointer to a null-terminated array of Unicode characters or an array of 8-bit signed integers. Si value est null ou un tableau vide, la valeur de la nouvelle chaîne est String.Empty.If value is null or an empty array, the value of the new string is String.Empty.
startIndex Int32 Index de l’élément de tableau qui définit le premier caractère de la nouvelle chaîne.The index of the array element that defines the first character in the new string.

Valeur par défaut : 0Default value: 0
length Int32 Nombre d’éléments de tableau à utiliser pour créer la nouvelle chaîne.The number of array elements to use to create the new string. Si la longueur est égale à zéro, le constructeur crée une chaîne dont la valeur est String.Empty.If length is zero, the constructor creates a string whose value is String.Empty.

Valeur par défaut : Array.LengthDefault value: Array.Length
enc Encoding Objet qui spécifie la façon dont le tableau de value est encodé.An object that specifies how the value array is encoded.

Valeur par défaut : Encoding.Defaultou la page de codes ANSI actuelle du systèmeDefault value: Encoding.Default, or the system's current ANSI code page

ExceptionsExceptions

Voici une liste des exceptions levées par les constructeurs qui n’incluent pas de paramètres de pointeur.Here's a list of exceptions thrown by constructors that don't include pointer parameters.

ExceptionException ConditionCondition Levée parThrown by
ArgumentNullException value a la valeur null.value is null. String(Char[], Int32, Int32)
ArgumentOutOfRangeException startIndex,lengthou count est inférieur à zéro.startIndex,length, or count is less than zero.

- ou --or-

La somme de startIndex et length est supérieure au nombre d’éléments de value.The sum of startIndex and length is greater than the number of elements in value.

- ou --or-

count est inférieur à zéro.count is less than zero.
String(Char, Int32)

String(Char[], Int32, Int32)

Voici une liste des exceptions levées par les constructeurs qui incluent des paramètres de pointeur.Here's a list of exceptions thrown by constructors that include pointer parameters.

ExceptionException ConditionCondition Levée parThrown by
ArgumentException value spécifie un tableau qui contient un caractère Unicode non valide.value specifies an array that contains an invalid Unicode character.

- ou --or-

value ou value + startIndex spécifie une adresse inférieure à 64 Ko.value or value + startIndex specifies an address that is less than 64K.

- ou --or-

Une nouvelle instance de String n’a pas pu être initialisée à partir du tableau d’octets value, car value n’utilise pas l’encodage de page de codes par défaut.A new String instance could not be initialized from the value byte array because value does not use the default code page encoding.
Tous les constructeurs avec des pointeurs.All constructors with pointers.
ArgumentNullException value a la valeur null.value is 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.The current process does not have read access to all the addressed characters.

- ou --or-

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.startIndex or length is less than zero, value + startIndex cause a pointer overflow, or the current process does not have read access to all the addressed characters.

- ou --or-

La longueur de la nouvelle chaîne est trop grande pour être allouée.The length of the new string is too large to allocate.
Tous les constructeurs avec des pointeurs.All constructors with pointers.
AccessViolationException value, ou value + startIndex + length-1, spécifie une adresse non valide.value, or value + startIndex + length - 1, specifies an invalid address. String(SByte*)

String(SByte*, Int32, Int32)

String(SByte*, Int32, Int32, Encoding)

Quelle méthode appelle-t-elle ?Which method do I call?

ÀTo Appel ou utilisationCall or use
Créer une chaîne.Create a string. Assignation à partir d’un littéral de chaîne ou d’une chaîne existante (exemple)Assignment from a string literal or an existing string (example)
Créer une chaîne à partir d’un tableau de caractères entier.Create a string from an entire character array. String(Char[]) (exemple)String(Char[]) (example)
Créer une chaîne à partir d’une partie d’un tableau de caractères.Create a string from a portion of a character array. String(Char[], Int32, Int32) (exemple)String(Char[], Int32, Int32) (example)
Créer une chaîne qui répète plusieurs fois le même caractère.Create a string that repeats the same character multiple times. String(Char, Int32) (exemple)String(Char, Int32) (example)
Créer une chaîne à partir d’un pointeur vers un tableau Unicode ou de caractères larges.Create a string from a pointer to a Unicode or wide character array. String(Char*)
Créez une chaîne à partir d’une partie d’un tableau de caractères Unicode ou étendu à l’aide de son pointeur.Create a string from a portion of a Unicode or wide character array by using its pointer. String(Char*, Int32, Int32)
Créez une chaîne à partir C++ d’un tableau de char.Create a string from a C++ char array. String(SByte*), String(SByte*, Int32, Int32)String(SByte*), String(SByte*, Int32, Int32)

- ou --or-

String(SByte*, Int32, Int32, Encoding)
Créer une chaîne à partir de caractères ASCII.Create a string from ASCII characters. ASCIIEncoding.GetString

Créer des chaînesCreating strings

La technique la plus couramment utilisée pour créer des chaînes par programmation est l’assignation simple, comme illustré dans cet exemple.The most commonly used technique for creating strings programmatically is simple assignment, as illustrated in this example. La classe String comprend également quatre types de surcharges de constructeur qui vous permettent de créer des chaînes à partir des valeurs suivantes :The String class also includes four types of constructor overloads that let you create strings from the following values:

  • À partir d’un tableau de caractères (tableau de caractères UTF-16).From a character array (an array of UTF-16-encoded characters). Vous pouvez créer un objet String à partir des caractères de l’ensemble du tableau ou d’une partie de celui-ci.You can create a new String object from the characters in the entire array or a portion of it. Le constructeur String(Char[]) copie tous les caractères du tableau dans la nouvelle chaîne.The String(Char[]) constructor copies all the characters in the array to the new string. Le constructeur String(Char[], Int32, Int32) copie les caractères de l’index startIndex vers l’index startIndex + length-1 vers la nouvelle chaîne.The String(Char[], Int32, Int32) constructor copies the characters from index startIndex to index startIndex + length - 1 to the new string. Si length est égal à zéro, la valeur de la nouvelle chaîne est String.Empty.If length is zero, the value of the new string is String.Empty.

    Si votre code instancie plusieurs fois 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.If your code repeatedly instantiates strings that have the same value, you can improve application performance by using an alternate means of creating strings. Pour plus d’informations, consultez gestion des chaînes répétitives.For more information, see Handling repetitive strings.

  • À partir d’un caractère unique qui est dupliqué zéro, une ou plusieurs fois, à l’aide du constructeur String(Char, Int32).From a single character that is duplicated zero, one, or more times, by using the String(Char, Int32) constructor. Si count est égal à zéro, la valeur de la nouvelle chaîne est String.Empty.If count is zero, the value of the new string is String.Empty.

  • D’un pointeur vers un tableau de caractères se terminant par null, à l’aide du constructeur String(Char*) ou String(Char*, Int32, Int32).From a pointer to a null-terminated character array, by using the String(Char*) or String(Char*, Int32, Int32) constructor. L’intégralité du tableau ou d’une plage spécifiée peut être utilisée pour initialiser la chaîne.Either the entire array or a specified range can be used to initialize the string. Le constructeur copie une séquence de caractères Unicode à partir du pointeur spécifié ou à partir du pointeur spécifié plus startIndex et en continuant jusqu’à la fin du tableau ou pour les caractères length.The constructor copies a sequence of Unicode characters starting from the specified pointer or from the specified pointer plus startIndex and continuing to the end of the array or for length characters. Si value est un pointeur null ou que length est égal à zéro, le constructeur crée une chaîne dont la valeur est String.Empty.If value is a null pointer or length is zero, the constructor creates a string whose value is String.Empty. Si l’opération de copie continue jusqu’à la fin du tableau et que le tableau ne se termine pas par un caractère null, le comportement du constructeur est dépendant du système.If the copy operation proceeds to the end of the array and the array is not null-terminated, the constructor behavior is system-dependent. Une telle condition peut entraîner une violation d’accès.Such a condition might cause an access violation.

    Si le tableau contient des caractères null incorporés (U + 0000 ou' \ 0 ') et que la surcharge String(Char*, Int32, Int32) est appelée, l’instance de chaîne contient des caractères length, y compris les valeurs NULL incorporées.If the array contains any embedded null characters (U+0000 or '\0') and the String(Char*, Int32, Int32) overload is called, the string instance contains length characters including any embedded nulls. L’exemple suivant montre ce qui se produit lorsqu’un pointeur vers un tableau de 10 éléments qui comprend deux caractères null est passé à la méthode String(Char*, Int32, Int32).The following example shows what happens when a pointer to an array of 10 elements that includes two null characters is passed to the String(Char*, Int32, Int32) method. É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.Because the address is the beginning of the array and all elements in the array are to be added to the string, the constructor instantiates a string with ten characters, including two embedded nulls. En revanche, si le même tableau est passé au constructeur String(Char*), le résultat est une chaîne de quatre caractères qui n’inclut pas le premier caractère null.On the other hand, if the same array is passed to the String(Char*) constructor, the result is a four-character string that does not include the first null character.

    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("{0:X4} ", Convert.ToUInt16(ch));
          Console.WriteLine();
          
          fixed(char* chPtr = chars) {
             s = new string(chPtr);         
          }
          
          foreach (var 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
    

    Le tableau doit contenir des caractères Unicode.The array must contain Unicode characters. Dans C++, cela signifie que le tableau de caractères doit être défini comme le type Char[] managé ou le typewchar_t[] non managé.In C++, this means that the character array must be defined either as the managed Char[] type or the unmanagedwchar_t[] type.

    Si la surcharge de String(Char*) est appelée et que le tableau n’est pas terminé par le caractère null, ou si la surcharge de String(Char*, Int32, Int32) est appelée et startIndex + length-1 comprend une plage à l’extérieur de la mémoire allouée pour la séquence de caractères , le comportement du constructeur est dépendant du système et une violation d’accès peut se produire.If the String(Char*) overload is called and the array is not null-terminated, or if the String(Char*, Int32, Int32) overload is called and startIndex + length-1 includes a range that it outside the memory allocated for the sequence of characters, the behavior of the constructor is system-dependent, and an access violation may occur. En outre, sur le processeur Intel Itanium, les appels au constructeur String(Char*, Int32, Int32) peuvent lever une exception DataMisalignedException.In addition, on the Intel Itanium processor, calls to the String(Char*, Int32, Int32) constructor may throw a DataMisalignedException exception. Si cela se produit, appelez plutôt le String(Char[], Int32, Int32).If this occurs, call the String(Char[], Int32, Int32) instead.

  • À partir d’un pointeur vers un tableau d’octets signé.From a pointer to a signed byte array. L’intégralité du tableau ou d’une plage spécifiée peut être utilisée pour initialiser la chaîne.Either the entire array or a specified range can be used to initialize the string. 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 de constructeur.The sequence of bytes can be interpreted by using the default code page encoding, or an encoding can be specified in the constructor call. Si le constructeur tente d’instancier une chaîne à partir d’un tableau entier qui ne se termine pas par un caractère null, ou si la plage du tableau de value + startIndex à value + startIndex + length-1 est en dehors de la mémoire alloué pour le tableau, le comportement de ce constructeur est dépendant du système et une violation d’accès peut se produire.If the constructor tries to instantiate a string from an entire array that is not null-terminated, or if the range of the array from value + startIndex to value + startIndex + length -1 is outside of the memory allocated for the array, the behavior of this constructor is system-dependent, and an access violation may occur.

    Les trois constructeurs qui incluent un tableau d’octets signé en tant que paramètre sont conçus principalement pour convertir C++ un tableau char en chaîne, comme illustré dans cet exemple :The three constructors that include a signed byte array as a parameter are designed primarily to convert a C++ char array to a string, as shown in this example:

    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 surcharge String(SByte*, Int32, Int32) est appelée, l’instance de chaîne contient des caractères length, y compris les valeurs NULL incorporées.If the array contains any null characters ('\0') or bytes whose value is 0 and the String(SByte*, Int32, Int32) overload is called, the string instance contains length characters including any embedded nulls. L’exemple suivant montre ce qui se produit lorsqu’un pointeur vers un tableau de 10 éléments qui comprend deux caractères null est passé à la méthode String(SByte*, Int32, Int32).The following example shows what happens when a pointer to an array of 10 elements that includes two null characters is passed to the String(SByte*, Int32, Int32) method. É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.Because the address is the beginning of the array and all elements in the array are to be added to the string, the constructor instantiates a string with ten characters, including two embedded nulls. En revanche, si le même tableau est passé au constructeur String(SByte*), le résultat est une chaîne de quatre caractères qui n’inclut pas le premier caractère null.On the other hand, if the same array is passed to the String(SByte*) constructor, the result is a four-character string that does not include the first null character.

    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("{0:X4} ", Convert.ToUInt16(ch));
          
          Console.WriteLine();    
    
          fixed(sbyte* bytePtr = bytes) {
             s = new string(bytePtr);         
          }
          
          foreach (var 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
    

    Étant donné que les constructeurs String(SByte*) et String(SByte*, Int32, Int32) interprètent 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 des systèmes différents.Because the String(SByte*) and String(SByte*, Int32, Int32) constructors interpret value by using the default ANSI code page, calling these constructors with identical byte arrays may create strings that have different values on different systems.

Gestion des chaînes répétitivesHandling repetitive strings

Les applications qui analysent ou décodent des flux de texte utilisent souvent le constructeur String(Char[], Int32, Int32) ou la méthode StringBuilder.Append(Char[], Int32, Int32) pour convertir des séquences de caractères en chaîne.Apps that parse or decode streams of text often use the String(Char[], Int32, Int32) constructor or the StringBuilder.Append(Char[], Int32, Int32) method to convert sequences of characters into a string. La création répétée de nouvelles chaînes avec la même valeur au lieu de la création et de la réutilisation d’une chaîne gaspille la mémoire.Repeatedly creating new strings with the same value instead of creating and reusing one string wastes memory. Si vous êtes susceptible de créer la même valeur de chaîne à plusieurs reprises en appelant le constructeur String(Char[], Int32, Int32), même si vous ne connaissez pas à l’avance ce que sont les valeurs de chaîne identiques, vous pouvez utiliser une table de recherche à la place.If you are likely to create the same string value repeatedly by calling the String(Char[], Int32, Int32) constructor, even if you don't know in advance what those identical string values may be, you can use a lookup table instead.

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.For example, suppose you read and parse a stream of characters from a file that contains XML tags and attributes. 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).When you parse the stream, you repeatedly encounter certain tokens (that is, sequences of characters that have a symbolic meaning). Les jetons équivalents aux chaînes « 0 », « 1 », « true » et « false » sont susceptibles de se produire fréquemment dans un flux XML.Tokens equivalent to the strings "0", "1", "true", and "false" are likely to occur frequently in an XML stream.

Au lieu de convertir chaque jeton en une nouvelle chaîne, vous pouvez créer un objet System.Xml.NameTable pour stocker les chaînes couramment en cours.Instead of converting each token into a new string, you can create a System.Xml.NameTable object to hold commonly occurring strings. L’objet NameTable améliore les performances, car il récupère les chaînes stockées sans allouer de mémoire temporaire.The NameTable object improves performance, because it retrieves stored strings without allocating temporary memory. Lorsque vous rencontrez un jeton, utilisez la méthode NameTable.Get(Char[], Int32, Int32) pour récupérer le jeton à partir de la table.When you encounter a token, use the NameTable.Get(Char[], Int32, Int32) method to retrieve the token from the table. Si le jeton existe, la méthode retourne la chaîne correspondante.If the token exists, the method returns the corresponding string. Si le jeton n’existe pas, utilisez la méthode NameTable.Add(Char[], Int32, Int32) pour insérer le jeton dans la table et pour récupérer la chaîne correspondante.If the token does not exist, use the NameTable.Add(Char[], Int32, Int32) method to insert the token into the table and to get the corresponding string.

Exemple 1 : utilisation de l’assignation de chaîneExample 1: Using string assignment

L’exemple suivant crée une nouvelle chaîne en lui assignant un littéral de chaîne.The following example creates a new string by assigning it a string literal. Elle crée une deuxième chaîne en lui assignant la valeur de la première chaîne.It creates a second string by assigning the value of the first string to it. Il s’agit des deux méthodes les plus courantes pour instancier un nouvel objet String.These are the two most common ways to instantiate a new String object.

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.
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 : utilisation d’un tableau de caractèresExample 2: Using a character array

L’exemple suivant montre comment créer un objet String à partir d’un tableau de caractères.The following example demonstrates how to create a new String object from a character array.

// 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
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 : utilisation d’une partie d’un tableau de caractères et répétition d’un caractère uniqueExample 3: Using a portion of a character array and repeating a single character

L’exemple suivant montre comment créer un objet String à partir d’une partie d’un tableau de caractères, et comment créer un nouvel objet String contenant plusieurs occurrences d’un caractère unique.The following example demonstrates how to create a new String object from a portion of a character array, and how to create a new String object that contains multiple occurrences of a single character.

// 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
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 : utilisation d’un pointeur vers un tableau de caractèresExample 4: Using a pointer to a character array

L’exemple suivant montre comment créer un objet String à partir d’un pointeur vers un tableau de caractères.The following example demonstrates how to create a new String object from a pointer to an array of characters. L' C# exemple doit être compilé à l’aide du commutateur de compilateur /unsafe.The C# example must be compiled by using the /unsafe compiler switch.

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!

Exemple 5 : instanciation d’une chaîne à partir d’un pointeur et d’une plage d’un tableauExample 5: Instantiating a string from a pointer and a range of an array

L’exemple suivant examine les éléments d’un tableau de caractères pour un point ou un point d’exclamation.The following example examines the elements of a character array for either a period or an exclamation point. Si un est trouvé, il instancie une chaîne à partir des caractères du tableau qui précèdent le symbole de ponctuation.If one is found, it instantiates a string from the characters in the array that precede the punctuation symbol. Si ce n’est pas le cas, il instancie une chaîne avec le contenu entier du tableau.If not, it instantiates a string with the entire contents of the array. L' C# exemple doit être compilé à l’aide du commutateur de compilateur /unsafe.The C# example must be compiled using the /unsafe compiler switch.

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

Exemple 6 : instanciation d’une chaîne à partir d’un pointeur vers un tableau d’octets signéExample 6: Instantiating a string from a pointer to a signed byte array

L’exemple suivant montre comment vous pouvez créer une instance de la classe String avec le constructeur String(SByte*).The following example demonstrates how you can create an instance of the String class with the String(SByte*) constructor.

// 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") );
}

Informations sur la versionVersion information

.NET Framework.NET Framework
Toutes les surcharges sont prises en charge dans : 4,5, 4, 3,5, 3,0, 2,0, 1,1, 1,0All overloads are supported in: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile.NET Framework Client Profile
Toutes les surcharges sont prises en charge dans : 4 3,5 SP1All overloads are supported in: 4, 3.5 SP1

Bibliothèque de classes portablePortable Class Library
Toutes les surcharges sans paramètre de* SBytesont prises en chargeAll overloads without an SByte* parameter are supported

.NET pour les applications du Windows Store.NET for Windows Store apps
Toutes les surcharges sans paramètre de * SBytesont prises en charge dans : Windows 8All overloads without an SByte* parameter are supported in: Windows 8

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.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters.

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

Paramètres

value
Char*

Pointeur vers un tableau de caractères Unicode terminé par un caractère null.A pointer to a null-terminated array of Unicode characters.

Attributs

Exceptions

Le processus actuel n’a pas d’accès en lecture à tous les caractères adressés.The current process does not have read access to all the addressed characters.

value spécifie un tableau qui contient un caractère Unicode non valide ou value spécifie une adresse inférieure à 64000.value specifies an array that contains an invalid Unicode character, or value specifies an address less than 64000.

Remarques

Notes

Pour obtenir des exemples et des informations complètes sur l’utilisation de ces surcharges de constructeur de String, consultez le résumé du constructeur String.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Sécurité

SecurityCriticalAttribute
Requiert une confiance totale pour l’appelant immédiat.requires full trust for the immediate caller. Ce membre ne peut pas être utilisé par du code de confiance partielle ou transparent.This member cannot be used by partially trusted or transparent code.

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é.Initializes a new instance of the String class to the Unicode characters indicated in the specified character array.

public:
 String(cli::array <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.An array of Unicode characters.

Remarques

Notes

Pour obtenir des exemples et des informations complètes sur l’utilisation de ces surcharges de constructeur de String, consultez le résumé du constructeur String.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

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.Initializes a new instance of the String class to the Unicode characters indicated in the specified read-only span.

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.A read-only span of Unicode characters.

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.Initializes a new instance of the String class to the value indicated by a pointer to an array of 8-bit signed integers.

public:
 String(System::SByte* value);
[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public String (sbyte* value);
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.A pointer to a null-terminated array of 8-bit signed integers. 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).The integers are interpreted using the current system code page encoding (that is, the encoding specified by Default).

Attributs

Exceptions

value a la valeur null.value is 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.A new instance of String could not be initialized using value, assuming value is encoded in 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.The length of the new string to initialize, which is determined by the null termination character of value, is too large to allocate.

value spécifie une adresse non valide.value specifies an invalid address.

Remarques

Notes

Pour obtenir des exemples et des informations complètes sur l’utilisation de ces surcharges de constructeur de String, consultez le résumé du constructeur String.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Sécurité

SecurityCriticalAttribute
Requiert une confiance totale pour l’appelant immédiat.requires full trust for the immediate caller. Ce membre ne peut pas être utilisé par du code de confiance partielle ou transparent.This member cannot be used by partially trusted or transparent code.

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.Initializes a new instance of the String class to the value indicated by a specified Unicode character repeated a specified number of times.

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.A Unicode character.

count
Int32

Nombre d'occurrences de c.The number of times c occurs.

Exceptions

count est inférieur à zéro.count is less than zero.

Remarques

Notes

Pour obtenir des exemples et des informations complètes sur l’utilisation de ces surcharges de constructeur de String, consultez le résumé du constructeur String.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

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.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters, a starting character position within that array, and a length.

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

Paramètres

value
Char*

Pointeur vers un tableau de caractères Unicode.A pointer to an array of Unicode characters.

startIndex
Int32

Position de départ dans value.The starting position within value.

length
Int32

Nombre de caractères dans value à utiliser.The number of characters within value to use.

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.startIndex or length is less than zero, value + startIndex cause a pointer overflow, or the current process does not have read access to all the addressed characters.

value spécifie un tableau qui contient un caractère Unicode non valide ou value + startIndex spécifie une adresse inférieure à 64000.value specifies an array that contains an invalid Unicode character, or value + startIndex specifies an address less than 64000.

Remarques

Notes

Pour obtenir des exemples et des informations complètes sur l’utilisation de ces surcharges de constructeur de String, consultez le résumé du constructeur String.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Sécurité

SecurityCriticalAttribute
Requiert une confiance totale pour l’appelant immédiat.requires full trust for the immediate caller. Ce membre ne peut pas être utilisé par du code de confiance partielle ou transparent.This member cannot be used by partially trusted or transparent code.

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.Initializes a new instance of the String class to the value indicated by an array of Unicode characters, a starting character position within that array, and a length.

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.An array of Unicode characters.

startIndex
Int32

Position de départ dans value.The starting position within value.

length
Int32

Nombre de caractères dans value à utiliser.The number of characters within value to use.

Exceptions

value a la valeur null.value is null.

startIndex ou length est inférieur à zéro.startIndex or length is less than zero.

- ou --or- La somme de startIndex et length est supérieure au nombre d’éléments de value.The sum of startIndex and length is greater than the number of elements in value.

Remarques

Notes

Pour obtenir des exemples et des informations complètes sur l’utilisation de ces surcharges de constructeur de String, consultez le résumé du constructeur String.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

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.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, and a length.

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

Paramètres

value
SByte*

Pointeur vers un tableau d'entiers signés 8 bits.A pointer to an array of 8-bit signed integers. 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).The integers are interpreted using the current system code page encoding (that is, the encoding specified by Default).

startIndex
Int32

Position de départ dans value.The starting position within value.

length
Int32

Nombre de caractères dans value à utiliser.The number of characters within value to use.

Attributs

Exceptions

value a la valeur null.value is null.

startIndex ou length est inférieur à zéro.startIndex or length is less than zero.

- ou --or- 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é.The address specified by value + startIndex is too large for the current platform; that is, the address calculation overflowed.

- ou --or- La longueur de la nouvelle chaîne à initialiser est trop grande à allouer.The length of the new string to initialize is too large to allocate.

L’adresse spécifiée par value + startIndex est inférieure à 64 Ko.The address specified by value + startIndex is less than 64K.

- ou --or- 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.A new instance of String could not be initialized using value, assuming value is encoded in ANSI.

value, startIndex et length spécifient collectivement une adresse non valide.value, startIndex, and length collectively specify an invalid address.

Remarques

Notes

Pour obtenir des exemples et des informations complètes sur l’utilisation de ces surcharges de constructeur de String, consultez le résumé du constructeur String.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Sécurité

SecurityCriticalAttribute
Requiert une confiance totale pour l’appelant immédiat.requires full trust for the immediate caller. Ce membre ne peut pas être utilisé par du code de confiance partielle ou transparent.This member cannot be used by partially trusted or transparent code.

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.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, a length, and an Encoding object.

public:
 String(System::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);
new string : nativeptr<sbyte> * int * int * System.Text.Encoding -> string

Paramètres

value
SByte*

Pointeur vers un tableau d'entiers signés 8 bits.A pointer to an array of 8-bit signed integers.

startIndex
Int32

Position de départ dans value.The starting position within value.

length
Int32

Nombre de caractères dans value à utiliser.The number of characters within value to use.

enc
Encoding

Objet qui spécifie la façon dont le tableau référencé par value est encodé.An object that specifies how the array referenced by value is encoded. Si enc est null, l'encodage ANSI est utilisé par défaut.If enc is null, ANSI encoding is assumed.

Attributs

Exceptions

value a la valeur null.value is null.

startIndex ou length est inférieur à zéro.startIndex or length is less than zero.

- ou --or- 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é.The address specified by value + startIndex is too large for the current platform; that is, the address calculation overflowed.

- ou --or- La longueur de la nouvelle chaîne à initialiser est trop grande à allouer.The length of the new string to initialize is too large to allocate.

L’adresse spécifiée par value + startIndex est inférieure à 64 Ko.The address specified by value + startIndex is less than 64K.

- ou --or- 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.A new instance of String could not be initialized using value, assuming value is encoded as specified by enc.

value, startIndex et length spécifient collectivement une adresse non valide.value, startIndex, and length collectively specify an invalid address.

Remarques

Notes

Pour obtenir des exemples et des informations complètes sur l’utilisation de ces surcharges de constructeur de String, consultez le résumé du constructeur String.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Sécurité

SecurityCriticalAttribute
Requiert une confiance totale pour l’appelant immédiat.requires full trust for the immediate caller. Ce membre ne peut pas être utilisé par du code de confiance partielle ou transparent.This member cannot be used by partially trusted or transparent code.

S’applique à