String String String String Constructors

Definizione

Overload

String(Char*) String(Char*) String(Char*)

Inizializza una nuova istanza della classe String sul valore indicato da uno specifico puntatore a una matrice di caratteri 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[]) String(Char[]) String(Char[]) String(Char[])

Inizializza una nuova istanza della classe String sul valore indicato da una matrice di caratteri Unicode.Initializes a new instance of the String class to the value indicated by an array of Unicode characters.

String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>)
String(SByte*) String(SByte*) String(SByte*)

Inizializza una nuova istanza della classe String sul valore indicato da un puntatore a una matrice di interi con segno a 8 bit.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) String(Char, Int32) String(Char, Int32) String(Char, Int32)

Inizializza una nuova istanza della classe String sul valore indicato da uno specifico carattere Unicode ripetuto un numero precisato di volte.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) String(Char*, Int32, Int32) String(Char*, Int32, Int32)

Inizializza una nuova istanza della classe String sul valore indicato da uno specifico puntatore a una matrice di caratteri Unicode, da una posizione iniziale del carattere all'interno di tale matrice e da una lunghezza.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) String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32)

Inizializza una nuova istanza della classe String sul valore indicato da una matrice di caratteri Unicode, da una posizione iniziale del carattere all'interno di tale matrice e da una lunghezza.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) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32)

Inizializza una nuova istanza della classe String sul valore indicato da uno specifico puntatore a una matrice di interi con segno a 8 bit, da una posizione iniziale all'interno di tale matrice e da una lunghezza.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) String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding)

Inizializza una nuova istanza della classe String sul valore indicato da uno specifico puntatore a una matrice di interi con segno a 8 bit, da una posizione iniziale all'interno di tale matrice e da un oggetto 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.

Commenti

Contenuto della sezione:In this section:

Sintassi del costruttore di overloadOverloaded constructor syntax
ParametriParameters
EccezioniExceptions
Quale metodo viene chiamato?Which method do I call?
Creazione di stringheCreating strings
Gestione delle stringhe ricorrentiHandling repetitive strings
Esempi di creazione di un'istanza di stringhe:Examples of instantiating strings:
Utilizzo dell'assegnazione di stringheUsing string assignment
Usando una matrice di caratteriUsing a character array
Utilizzo di una parte di una matrice di caratteri e la ripetizione di un singolo carattereUsing a portion of a character array and repeating a single character
Usando un puntatore a una matrice di caratteriUsing a pointer to a character array
Usando un puntatore e un intervallo di una matriceUsing a pointer and a range of an array
Usando un puntatore a una matrice di byte con segnoUsing a pointer to a signed byte array
Informazioni sulla versioneVersion information

Sintassi del costruttore di overloadOverloaded constructor syntax

Costruttori di stringhe possono essere suddivise in due categorie: quelli senza parametri dei puntatori e quelli con i parametri di puntatore.String constructors fall into two categories: those without pointer parameters, and those with pointer parameters. I costruttori che utilizzano i puntatori non sono conformi a CLS.The constructors that use pointers are not CLS-compliant. Inoltre, Visual Basic non supporta l'utilizzo dei puntatori e c# richiede codice che usa puntatori per l'esecuzione in un contesto unsafe.In addition, Visual Basic does not support the use of pointers, and C# requires code that uses pointers to run in an unsafe context. Per altre informazioni, vedere unsafe.For more information, see unsafe.

Per altro materiale sussidiario sulla scelta di un overload, vedere quale metodo viene chiamato?For additional guidance on choosing an overload, see Which method do I call?

String(Char[] value)
Inizializza la nuova istanza sul valore indicato da una matrice di caratteri Unicode.Initializes the new instance to the value indicated by an array of Unicode characters. Questo costruttore copia i caratteri Unicode (esempio).This constructor copies Unicode characters(example).

String(Char[] value, Int32 startIndex, Int32 length)
Inizializza la nuova istanza sul valore indicato da una matrice di caratteri Unicode, una posizione di carattere iniziale all'interno di tale matrice e una lunghezza (esempio).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)
Consente di inizializzare la nuova istanza per il valore indicata da uno specifico carattere Unicode ripetuto un numero precisato di volte in cui (esempio).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 a CLS) Inizializza la nuova istanza sul valore indicato da un puntatore a una matrice di caratteri Unicode che termina con un carattere null (u+0000 o '\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'). (example).(example).

Autorizzazione: SecurityCriticalAttribute, richiede l'attendibilità totale per il chiamante immediato.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Questo membro non può essere utilizzato da codice parzialmente attendibile o trasparente.This member cannot be used by partially trusted or transparent code.

String(char* value, Int32 startIndex, Int32 length)
(Non conforme a CLS) Inizializza la nuova istanza sul valore indicato da un puntatore a una matrice di caratteri Unicode, da una posizione di carattere iniziale all'interno di tale matrice e una lunghezza.(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. Il costruttore di copia i caratteri Unicode compresi value iniziando dall'indice startIndex e termina in corrispondenza dell'indice startIndex + length - 1 (esempio).The constructor copies the Unicode characters from value starting at index startIndex and ending at index startIndex + length - 1 (example).

Autorizzazione: SecurityCriticalAttribute, richiede l'attendibilità totale per il chiamante immediato.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Questo membro non può essere utilizzato da codice parzialmente attendibile o trasparente.This member cannot be used by partially trusted or transparent code.

String(SByte* value)
(Non conforme a CLS) Inizializza la nuova istanza sul valore indicato da un puntatore a una matrice di interi con segno a 8 bit.(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of 8-bit signed integers. Si presuppone che la matrice rappresentano una stringa codificata utilizzando la tabella codici del sistema corrente (vale a dire, la codifica specificata da 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). Il costruttore elabora i caratteri value a partire dalla posizione specificata dal puntatore fino a quando non viene raggiunto un carattere null (0x00) (esempio).The constructor processes characters from value starting from the location specified by the pointer until a null character (0x00) is reached (example).

Autorizzazione: SecurityCriticalAttribute, richiede l'attendibilità totale per il chiamante immediato.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Questo membro non può essere utilizzato da codice parzialmente attendibile o trasparente.This member cannot be used by partially trusted or transparent code.

String(SByte* value, Int32 startIndex, Int32 length)
(Non conforme a CLS) Inizializza la nuova istanza sul valore indicato da un puntatore a una matrice di interi con segno a 8 bit, una posizione iniziale all'interno di tale matrice e una lunghezza.(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. Si presuppone che la matrice rappresentano una stringa codificata utilizzando la tabella codici del sistema corrente (vale a dire, la codifica specificata da 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). Il costruttore elabora i caratteri dal valore partire startIndex a startIndex + length - 1 (esempio).The constructor processes characters from value starting at startIndex and ending at startIndex + length - 1 (example).

Autorizzazione: SecurityCriticalAttribute, richiede l'attendibilità totale per il chiamante immediato.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Questo membro non può essere utilizzato da codice parzialmente attendibile o trasparente.This member cannot be used by partially trusted or transparent code.

String(SByte* value, Int32 startIndex, Int32 length, Encoding enc)
(Non conforme a CLS) Inizializza la nuova istanza sul valore indicato da un puntatore a una matrice di interi con segno a 8 bit, una posizione iniziale all'interno della matrice, una lunghezza e un Encoding oggetto.(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.

Autorizzazione: SecurityCriticalAttribute, richiede l'attendibilità totale per il chiamante immediato.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Questo membro non può essere utilizzato da codice parzialmente attendibile o trasparente.This member cannot be used by partially trusted or transparent code.

ParametriParameters

Ecco un elenco completo dei parametri usati dalla String costruttori che non includono un parametro del puntatore.Here is a complete list of parameters used by String constructors that don't include a pointer parameter. Per i parametri usati da ogni overload, vedere la sintassi di overload precedente.For the parameters used by each overload, see the overload syntax above.

ParametroParameter TipoType DescrizioneDescription
value Char[][] Matrice di caratteri Unicode.An array of Unicode characters.
c Char Carattere Unicode.A Unicode character.
startIndex Int32 Posizione iniziale in value del primo carattere nella stringa di nuovo.The starting position in value of the first character in the new string.

Valore predefinito: 0Default value: 0
length Int32 Il numero di caratteri in value da includere nella nuova stringa.The number of characters in value to include in the new string.

Valore predefinito:Default value: Array.Length
count Int32 Numero di occorrenze del carattere c viene ripetuta nella stringa di nuovo.The number of times the character c is repeated in the new string. Se count è uguale a zero, il valore del nuovo oggetto è String.Empty.If count is zero, the value of the new object is String.Empty.

Ecco un elenco completo dei parametri usati dalla String costruttori che includono un parametro del puntatore.Here is a complete list of parameters used by String constructors that include a pointer parameter. Per i parametri usati da ogni overload, vedere la sintassi di overload precedente.For the parameters used by each overload, see the overload syntax above.

ParametroParameter TipoType DescrizioneDescription
value Char*

In alternativa-or-

SByte*
Puntatore a una matrice con terminazione null di caratteri Unicode o una matrice di interi con segno a 8 bit.A pointer to a null-terminated array of Unicode characters or an array of 8-bit signed integers. Se value viene null o una matrice vuota, il valore della nuova stringa è String.Empty.If value is null or an empty array, the value of the new string is String.Empty.
startIndex Int32 L'indice dell'elemento della matrice che definisce il primo carattere nella stringa di nuovo.The index of the array element that defines the first character in the new string.

Valore predefinito: 0Default value: 0
length Int32 Il numero di elementi della matrice da usare per creare la nuova stringa.The number of array elements to use to create the new string. Se la lunghezza è zero, il costruttore crea una stringa il cui valore è String.Empty.If length is zero, the constructor creates a string whose value is String.Empty.

Valore predefinito:Default value: Array.Length
enc Encoding Oggetto che specifica come il value matrice viene codificata.An object that specifies how the value array is encoded.

Il valore predefinito: Encoding.Default, o tabella codici ANSI corrente del sistemaDefault value: Encoding.Default, or the system's current ANSI code page

EccezioniExceptions

Ecco un elenco delle eccezioni generate dai costruttori che non includono i parametri di puntatore.Here's a list of exceptions thrown by constructors that don't include pointer parameters.

EccezioneException CondizioneCondition Generata daThrown by
ArgumentNullException value è null.is null. String(Char[], Int32, Int32)
ArgumentOutOfRangeException startIndex,length, o count è minore di zero.,length, or count is less than zero.

In alternativa-or-

La somma di startIndex e length è maggiore del numero di elementi in value.The sum of startIndex and length is greater than the number of elements in value.

In alternativa-or-

count è minore di zero.is less than zero.
String(Char, Int32)

String(Char[], Int32, Int32)

Ecco un elenco delle eccezioni generate dai costruttori che includono parametri di puntatore.Here's a list of exceptions thrown by constructors that include pointer parameters.

EccezioneException CondizioneCondition Generata daThrown by
ArgumentException value Specifica una matrice che contiene un carattere Unicode non valido.specifies an array that contains an invalid Unicode character.

In alternativa-or-

value oppure value + startIndex specifica un indirizzo minore di 64 K.or value + startIndex specifies an address that is less than 64K.

In alternativa-or-

Una nuova String istanza nelze inicializovat dal value della matrice di byte perché value non usa l'impostazione predefinita codifica della tabella codici.A new String instance could not be initialized from the value byte array because value does not use the default code page encoding.
Tutti i costruttori con i puntatori.All constructors with pointers.
ArgumentNullException value è null.is null. String(SByte*)

String(SByte*, Int32, Int32)

String(SByte*, Int32, Int32, Encoding)
ArgumentOutOfRangeException Il processo corrente non ha accesso in lettura a tutti i caratteri considerati.The current process does not have read access to all the addressed characters.

In alternativa-or-

startIndex oppure length è minore di zero value + startIndex causa un overflow del puntatore o il processo corrente non ha accesso in lettura a tutti i caratteri considerati.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.

In alternativa-or-

La lunghezza della nuova stringa è troppo grande da allocare.The length of the new string is too large to allocate.
Tutti i costruttori con i puntatori.All constructors with pointers.
AccessViolationException value, oppure value + startIndex + length -1, specifica un indirizzo non valido., or value + startIndex + length - 1, specifies an invalid address. String(SByte*)

String(SByte*, Int32, Int32)

String(SByte*, Int32, Int32, Encoding)

Quale metodo viene chiamato?Which method do I call?

ATo Chiamata o utilizzoCall or use
Creare una stringa.Create a string. Assegnazione di un valore letterale stringa o una stringa esistente (esempio)Assignment from a string literal or an existing string (example)
Creare una stringa da un'intera matrice di caratteri.Create a string from an entire character array. String(Char[]) (example)(example)
Creare una stringa da una parte di una matrice di caratteri.Create a string from a portion of a character array. String(Char[], Int32, Int32) (example)(example)
Creare una stringa che ripete più volte lo stesso carattere.Create a string that repeats the same character multiple times. String(Char, Int32) (example)(example)
Creare una stringa da un puntatore a una matrice di caratteri "wide" o Unicode.Create a string from a pointer to a Unicode or wide character array. String(Char*)
Creare una stringa da una parte di una matrice di caratteri "wide" o Unicode usando il relativo puntatore.Create a string from a portion of a Unicode or wide character array by using its pointer. String(Char*, Int32, Int32)
Creare una stringa da C++ char matrice.Create a string from a C++ char array. String(SByte*),, String(SByte*, Int32, Int32)

In alternativa-or-

String(SByte*, Int32, Int32, Encoding)
Creare una stringa di caratteri ASCII.Create a string from ASCII characters. ASCIIEncoding.GetString

Creazione di stringheCreating strings

Uso più comune tecnica per la creazione di stringhe a livello di codice è semplice assegnazione, come illustrato nella in questo esempio.The most commonly used technique for creating strings programmatically is simple assignment, as illustrated in this example. Il String classe include anche i quattro tipi di overload del costruttore che consentono di creare stringhe tra i valori seguenti:The String class also includes four types of constructor overloads that let you create strings from the following values:

  • Da una matrice di caratteri (una matrice di caratteri con codifica UTF-16).From a character array (an array of UTF-16-encoded characters). È possibile creare un nuovo String oggetto verso i caratteri nell'intera matrice o una parte di esso.You can create a new String object from the characters in the entire array or a portion of it. Il String(Char[]) costruttore copia tutti i caratteri nella matrice per la nuova stringa.The String(Char[]) constructor copies all the characters in the array to the new string. Il String(Char[], Int32, Int32) costruttore di copia i caratteri da indice startIndex all'indice startIndex + length -1 per la nuova stringa.The String(Char[], Int32, Int32) constructor copies the characters from index startIndex to index startIndex + length - 1 to the new string. Se length è uguale a zero, il valore della nuova stringa è String.Empty.If length is zero, the value of the new string is String.Empty.

    Se il codice ripetutamente crea un'istanza di stringhe con lo stesso valore, è possibile migliorare le prestazioni dell'applicazione usando un metodo alternativo di creazione di stringhe.If your code repeatedly instantiates strings that have the same value, you can improve application performance by using an alternate means of creating strings. Per altre informazioni, vedere gestione delle stringhe ripetitive.For more information, see Handling repetitive strings.

  • Da un singolo carattere che è duplicato uguale a zero, uno, o più volte, usando il String(Char, Int32) costruttore.From a single character that is duplicated zero, one, or more times, by using the String(Char, Int32) constructor. Se count è uguale a zero, il valore della nuova stringa è String.Empty.If count is zero, the value of the new string is String.Empty.

  • Da un puntatore a una matrice di caratteri con terminazione null, tramite il String(Char*) o String(Char*, Int32, Int32) costruttore.From a pointer to a null-terminated character array, by using the String(Char*) or String(Char*, Int32, Int32) constructor. L'intera matrice o un intervallo specificato è utilizzabile per inizializzare la stringa.Either the entire array or a specified range can be used to initialize the string. Il costruttore di copia una sequenza di caratteri Unicode a partire dal puntatore specificato o dal puntatore sul segno più startIndex e proseguire fino alla fine della matrice o per length caratteri.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. Se value è un puntatore null o length è uguale a zero, il costruttore crea una stringa il cui valore è String.Empty.If value is a null pointer or length is zero, the constructor creates a string whose value is String.Empty. Se l'operazione di copia continua alla fine della matrice e la matrice non è con terminazione null, il comportamento del costruttore è dipendente dal sistema.If the copy operation proceeds to the end of the array and the array is not null-terminated, the constructor behavior is system-dependent. Tale condizione potrebbe causare una violazione di accesso.Such a condition might cause an access violation.

    Se la matrice contiene eventuali caratteri null incorporati (u+0000 o '\0') e il String(Char*, Int32, Int32) viene chiamato l'overload, l'istanza di stringa contiene length caratteri inclusi quelli incorporati i valori null.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'esempio seguente mostra cosa accade quando viene passato un puntatore a una matrice di 10 elementi che include due caratteri null per il String(Char*, Int32, Int32) (metodo).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. Poiché l'indirizzo è l'inizio della matrice e tutti gli elementi nella matrice devono essere aggiunti alla stringa, il costruttore crea un'istanza di una stringa con dieci caratteri, inclusi due valori null incorporati.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. D'altra parte, se la stessa matrice viene passata per il String(Char*) costruttore, il risultato è una stringa di quattro caratteri che non include al primo carattere 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
    

    La matrice deve contenere caratteri Unicode.The array must contain Unicode characters. In C++, questo significa che la matrice di caratteri deve essere definito come gestita Chartipo [] o non gestitowchar_ttipo [].In C++, this means that the character array must be defined either as the managed Char[] type or the unmanagedwchar_t[] type.

    Se il String(Char*) l'overload del metodo e la matrice non è con terminazione null, o se il String(Char*, Int32, Int32) l'overload del metodo e startIndex + length-1 include un intervallo all'esterno della memoria allocata per la sequenza di caratteri, il comportamento del costruttore è dipendente dal sistema e potrebbe verificarsi una violazione di accesso.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. Inoltre, sul processore Intel Itanium, le chiamate al String(Char*, Int32, Int32) costruttore può generare un DataMisalignedException eccezione.In addition, on the Intel Itanium processor, calls to the String(Char*, Int32, Int32) constructor may throw a DataMisalignedException exception. Se in questo caso, chiamare il String(Char[], Int32, Int32) invece.If this occurs, call the String(Char[], Int32, Int32) instead.

  • Da un puntatore a una matrice di byte con segno.From a pointer to a signed byte array. L'intera matrice o un intervallo specificato è utilizzabile per inizializzare la stringa.Either the entire array or a specified range can be used to initialize the string. La sequenza di byte può essere interpretata con la tabella codici predefinita di codifica o una codifica può essere specificata nella chiamata al costruttore.The sequence of bytes can be interpreted by using the default code page encoding, or an encoding can be specified in the constructor call. Se il costruttore tenta di creare un'istanza di una stringa da un'intera matrice che non è con terminazione null oppure se l'intervallo della matrice da value + startIndex al value + startIndex + length -1 è all'esterno della memoria allocata per l'array, il comportamento di questo costruttore è dipendente dal sistema e potrebbe verificarsi una violazione di accesso.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.

    I tre costruttori che includono una matrice di byte con segno come parametro sono progettati principalmente per convertire un C++ char della matrice in una stringa, come illustrato in questo esempio: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
    

    Se la matrice contiene i caratteri null ('\0') o byte il cui valore è 0 e il String(SByte*, Int32, Int32) viene chiamato l'overload, l'istanza di stringa contiene length caratteri inclusi quelli incorporati i valori null.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'esempio seguente mostra cosa accade quando viene passato un puntatore a una matrice di 10 elementi che include due caratteri null per il String(SByte*, Int32, Int32) (metodo).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. Poiché l'indirizzo è l'inizio della matrice e tutti gli elementi nella matrice devono essere aggiunti alla stringa, il costruttore crea un'istanza di una stringa con dieci caratteri, inclusi due valori null incorporati.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. D'altra parte, se la stessa matrice viene passata per il String(SByte*) costruttore, il risultato è una stringa di quattro caratteri che non include al primo carattere 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
    

    Poiché il String(SByte*) e String(SByte*, Int32, Int32) costruttori interpretano value usando la tabella codici ANSI predefinita, la chiamata di questi costruttori con matrici di byte identici può creare stringhe con valori diversi a seconda del sistema.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.

Gestione delle stringhe ricorrentiHandling repetitive strings

Le app che analizzano o decodificano i flussi di testo spesso usano il String(Char[], Int32, Int32) costruttore o StringBuilder.Append(Char[], Int32, Int32) metodo per convertire le sequenze di caratteri in una stringa.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. Creazione di nuove stringhe a più volte con lo stesso valore anziché creando e riutilizzando una sola stringa comporta uno spreco di memoria.Repeatedly creating new strings with the same value instead of creating and reusing one string wastes memory. Se è probabile che creare più volte lo stesso valore di stringa chiamando il String(Char[], Int32, Int32) costruttore, anche se non si conosce anticipo quali potrebbero essere tali valori di stringa identica, è possibile usare invece una tabella di ricerca.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.

Si supponga, ad esempio, leggere e analizzare il flusso di caratteri da un file che contiene tag e attributi XML.For example, suppose you read and parse a stream of characters from a file that contains XML tags and attributes. Quando si analizza il flusso, si verifica più volte alcuni token (vale a dire, sequenze di caratteri che hanno un significato simbolico).When you parse the stream, you repeatedly encounter certain tokens (that is, sequences of characters that have a symbolic meaning). Token equivalenti per le stringhe "0", "1", "true" e "false" è probabile che si verificano di frequente in un flusso XML.Tokens equivalent to the strings "0", "1", "true", and "false" are likely to occur frequently in an XML stream.

Anziché convertire ogni token in una nuova stringa, è possibile creare un System.Xml.NameTable oggetto per contenere le stringhe che si verificano comunemente.Instead of converting each token into a new string, you can create a System.Xml.NameTable object to hold commonly occurring strings. Il NameTable oggetto migliora le prestazioni, poiché recupera stringhe archiviate senza allocare memoria temporanea.The NameTable object improves performance, because it retrieves stored strings without allocating temporary memory. Quando si verifica un token, usare il NameTable.Get(Char[], Int32, Int32) metodo per recuperare il token dalla tabella.When you encounter a token, use the NameTable.Get(Char[], Int32, Int32) method to retrieve the token from the table. Se il token non esiste, il metodo restituisce la stringa corrispondente.If the token exists, the method returns the corresponding string. Se il token non esiste, usare il NameTable.Add(Char[], Int32, Int32) metodo per inserire il token nella tabella e per ottenere la stringa corrispondente.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.

Esempio 1: Utilizzo dell'assegnazione di stringheExample 1: Using string assignment

L'esempio seguente crea una nuova stringa assegnandole un valore letterale stringa.The following example creates a new string by assigning it a string literal. Viene creata una seconda stringa assegnando il valore della prima stringa a esso.It creates a second string by assigning the value of the first string to it. Questi sono i due modi più comuni per creare un'istanza di un nuovo String oggetto.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.

Esempio 2: Usando una matrice di caratteriExample 2: Using a character array

Nell'esempio seguente viene illustrato come creare un nuovo String oggetto da una matrice di caratteri.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))) 

Esempio 3: Utilizzo di una parte di una matrice di caratteri e la ripetizione di un singolo carattereExample 3: Using a portion of a character array and repeating a single character

Nell'esempio seguente viene illustrato come creare una nuova String da una parte di una matrice di caratteri e su come creare un nuovo oggetto String oggetto che contiene più occorrenze di un singolo carattere.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)

Esempio 4: Usando un puntatore a una matrice di caratteriExample 4: Using a pointer to a character array

Nell'esempio seguente viene illustrato come creare un nuovo String oggetto da un puntatore a una matrice di caratteri.The following example demonstrates how to create a new String object from a pointer to an array of characters. Nell'esempio c# debba essere compilata usando la /unsafe opzione del compilatore.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!

Esempio 5: Creare un'istanza di una stringa da un puntatore e un intervallo di una matriceExample 5: Instantiating a string from a pointer and a range of an array

Nell'esempio seguente esamina gli elementi di una matrice di caratteri per un punto o un punto esclamativo.The following example examines the elements of a character array for either a period or an exclamation point. Se viene trovata, crea un'istanza di una stringa di caratteri nella matrice che precedono il simbolo di punteggiatura.If one is found, it instantiates a string from the characters in the array that precede the punctuation symbol. In caso contrario, viene creata un'istanza di una stringa con l'intero contenuto della matrice.If not, it instantiates a string with the entire contents of the array. Nell'esempio c# deve essere compilata usando la /unsafe opzione del compilatore.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

Esempio 6: Creare un'istanza di una stringa da un puntatore a una matrice di byte con segnoExample 6: Instantiating a string from a pointer to a signed byte array

Nell'esempio seguente viene illustrato come è possibile creare un'istanza di String classe con il String(SByte*) costruttore.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") );
}

Informazioni sulla versioneVersion information

.NET Framework.NET Framework
Tutti gli overload sono supportati in: 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
Tutti gli overload sono supportati in: 4, 3.5 SP1All overloads are supported in: 4, 3.5 SP1

Libreria di classi portabilePortable Class Library
Tutti gli overload senza un SByte* parametro sono supportatiAll overloads without an SByte* parameter are supported

.NET per app di Windows Store.NET for Windows Store apps
Tutti gli overload senza un SByte* parametro sono supportati in: Windows 8All overloads without an SByte* parameter are supported in: Windows 8

String(Char*) String(Char*) String(Char*)

Importante

Questa API non è conforme a CLS.

Inizializza una nuova istanza della classe String sul valore indicato da uno specifico puntatore a una matrice di caratteri 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

Parametri

value
Char*

Puntatore a una matrice con terminazione Null di caratteri Unicode.A pointer to a null-terminated array of Unicode characters.

Eccezioni

Il processo corrente non ha accesso in lettura a tutti i caratteri considerati.The current process does not have read access to all the addressed characters.

value specifica una matrice che contiene un carattere Unicode non valido o value specifica un indirizzo minore di 64000.specifies an array that contains an invalid Unicode character, or value specifies an address less than 64000.

Commenti

Nota

Per esempi e informazioni sull'utilizzo complete su questo e altri String overload del costruttore, vedere il String costruttore riepilogo.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Sicurezza

SecurityCriticalAttribute
richiede l'attendibilità totale per il chiamante immediato.requires full trust for the immediate caller. Questo membro non può essere utilizzato da codice parzialmente attendibile o trasparente.This member cannot be used by partially trusted or transparent code.

String(Char[]) String(Char[]) String(Char[]) String(Char[])

Inizializza una nuova istanza della classe String sul valore indicato da una matrice di caratteri Unicode.Initializes a new instance of the String class to the value indicated by an array of Unicode characters.

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

Parametri

value
Char[]

Matrice di caratteri Unicode.An array of Unicode characters.

Commenti

Nota

Per esempi e informazioni sull'utilizzo complete su questo e altri String overload del costruttore, vedere il String costruttore riepilogo.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>)

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

Parametri

String(SByte*) String(SByte*) String(SByte*)

Importante

Questa API non è conforme a CLS.

Inizializza una nuova istanza della classe String sul valore indicato da un puntatore a una matrice di interi con segno a 8 bit.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

Parametri

value
SByte*

Puntatore a una matrice a terminazione Null di interi con segno a 8 bit.A pointer to a null-terminated array of 8-bit signed integers. I numeri interi vengono interpretati in base alla codifica della tabella codici di sistema corrente, ovvero alla codifica specificata da Default.The integers are interpreted using the current system code page encoding (that is, the encoding specified by Default).

Eccezioni

Non è stato possibile inizializzare una nuova istanza di String mediante value, supponendo che value sia codificato in ANSI.A new instance of String could not be initialized using value, assuming value is encoded in ANSI.

La lunghezza della nuova stringa da inizializzare, che è determinata dal carattere a terminazione Null del parametro value, è troppo grande da allocare.The length of the new string to initialize, which is determined by the null termination character of value, is too large to allocate.

value specifica un indirizzo non valido.specifies an invalid address.

Commenti

Nota

Per esempi e informazioni sull'utilizzo complete su questo e altri String overload del costruttore, vedere il String costruttore riepilogo.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Sicurezza

SecurityCriticalAttribute
richiede l'attendibilità totale per il chiamante immediato.requires full trust for the immediate caller. Questo membro non può essere utilizzato da codice parzialmente attendibile o trasparente.This member cannot be used by partially trusted or transparent code.

String(Char, Int32) String(Char, Int32) String(Char, Int32) String(Char, Int32)

Inizializza una nuova istanza della classe String sul valore indicato da uno specifico carattere Unicode ripetuto un numero precisato di volte.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)

Parametri

c
Char Char Char Char

Carattere Unicode.A Unicode character.

count
Int32 Int32 Int32 Int32

Numero di volte in cui si presenta il parametro c.The number of times c occurs.

Eccezioni

Commenti

Nota

Per esempi e informazioni sull'utilizzo complete su questo e altri String overload del costruttore, vedere il String costruttore riepilogo.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

String(Char*, Int32, Int32) String(Char*, Int32, Int32) String(Char*, Int32, Int32)

Importante

Questa API non è conforme a CLS.

Inizializza una nuova istanza della classe String sul valore indicato da uno specifico puntatore a una matrice di caratteri Unicode, da una posizione iniziale del carattere all'interno di tale matrice e da una lunghezza.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

Parametri

value
Char*

Puntatore a una matrice di caratteri Unicode.A pointer to an array of Unicode characters.

startIndex
Int32 Int32 Int32 Int32

Posizione iniziale all'interno di value.The starting position within value.

length
Int32 Int32 Int32 Int32

Numero di caratteri in value da usare.The number of characters within value to use.

Eccezioni

startIndex o length è minore di zero, value + startIndex causa un overflow del puntatore o il processo corrente non ha accesso in lettura a tutti i caratteri considerati.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 specifica una matrice che contiene un carattere Unicode non valido o value + startIndex specifica un indirizzo minore di 64000.specifies an array that contains an invalid Unicode character, or value + startIndex specifies an address less than 64000.

Commenti

Nota

Per esempi e informazioni sull'utilizzo complete su questo e altri String overload del costruttore, vedere il String costruttore riepilogo.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Sicurezza

SecurityCriticalAttribute
richiede l'attendibilità totale per il chiamante immediato.requires full trust for the immediate caller. Questo membro non può essere utilizzato da codice parzialmente attendibile o trasparente.This member cannot be used by partially trusted or transparent code.

String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32)

Inizializza una nuova istanza della classe String sul valore indicato da una matrice di caratteri Unicode, da una posizione iniziale del carattere all'interno di tale matrice e da una lunghezza.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)

Parametri

value
Char[]

Matrice di caratteri Unicode.An array of Unicode characters.

startIndex
Int32 Int32 Int32 Int32

Posizione iniziale all'interno di value.The starting position within value.

length
Int32 Int32 Int32 Int32

Numero di caratteri in value da usare.The number of characters within value to use.

Eccezioni

startIndex o length è minore di zero.or length is less than zero.

In alternativa-or- La somma di startIndex e length è maggiore del numero di elementi in value.The sum of startIndex and length is greater than the number of elements in value.

Commenti

Nota

Per esempi e informazioni sull'utilizzo complete su questo e altri String overload del costruttore, vedere il String costruttore riepilogo.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

String(SByte*, Int32, Int32) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32)

Importante

Questa API non è conforme a CLS.

Inizializza una nuova istanza della classe String sul valore indicato da uno specifico puntatore a una matrice di interi con segno a 8 bit, da una posizione iniziale all'interno di tale matrice e da una lunghezza.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

Parametri

value
SByte*

Puntatore a una matrice di interi con segno a 8 bit.A pointer to an array of 8-bit signed integers. I numeri interi vengono interpretati in base alla codifica della tabella codici di sistema corrente, ovvero alla codifica specificata da Default.The integers are interpreted using the current system code page encoding (that is, the encoding specified by Default).

startIndex
Int32 Int32 Int32 Int32

Posizione iniziale all'interno di value.The starting position within value.

length
Int32 Int32 Int32 Int32

Numero di caratteri in value da usare.The number of characters within value to use.

Eccezioni

startIndex o length è minore di zero.or length is less than zero.

In alternativa-or- L'indirizzo specificato da value + startIndex è troppo grande per la piattaforma corrente, ovvero il calcolo dell'indirizzo ha causato un overflow.The address specified by value + startIndex is too large for the current platform; that is, the address calculation overflowed.

In alternativa-or- La lunghezza della nuova stringa da inizializzare è troppo grande da allocare.The length of the new string to initialize is too large to allocate.

L'indirizzo specificato da value + startIndex è minore di 64 K.The address specified by value + startIndex is less than 64K.

In alternativa-or- Non è stato possibile inizializzare una nuova istanza di String mediante value, supponendo che value sia codificato in ANSI.A new instance of String could not be initialized using value, assuming value is encoded in ANSI.

value, startIndex e length specificano collettivamente un indirizzo non valido., startIndex, and length collectively specify an invalid address.

Commenti

Nota

Per esempi e informazioni sull'utilizzo complete su questo e altri String overload del costruttore, vedere il String costruttore riepilogo.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Sicurezza

SecurityCriticalAttribute
richiede l'attendibilità totale per il chiamante immediato.requires full trust for the immediate caller. Questo membro non può essere utilizzato da codice parzialmente attendibile o trasparente.This member cannot be used by partially trusted or transparent code.

String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding)

Importante

Questa API non è conforme a CLS.

Inizializza una nuova istanza della classe String sul valore indicato da uno specifico puntatore a una matrice di interi con segno a 8 bit, da una posizione iniziale all'interno di tale matrice e da un oggetto 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

Parametri

value
SByte*

Puntatore a una matrice di interi con segno a 8 bit.A pointer to an array of 8-bit signed integers.

startIndex
Int32 Int32 Int32 Int32

Posizione iniziale all'interno di value.The starting position within value.

length
Int32 Int32 Int32 Int32

Numero di caratteri in value da usare.The number of characters within value to use.

enc
Encoding Encoding Encoding Encoding

Oggetto che specifica la modalità di codifica della matrice cui fa riferimento il parametro value.An object that specifies how the array referenced by value is encoded. Se il parametro enc è null, verrà usata la codifica ANSI.If enc is null, ANSI encoding is assumed.

Eccezioni

startIndex o length è minore di zero.or length is less than zero.

In alternativa-or- L'indirizzo specificato da value + startIndex è troppo grande per la piattaforma corrente, ovvero il calcolo dell'indirizzo ha causato un overflow.The address specified by value + startIndex is too large for the current platform; that is, the address calculation overflowed.

In alternativa-or- La lunghezza della nuova stringa da inizializzare è troppo grande da allocare.The length of the new string to initialize is too large to allocate.

L'indirizzo specificato da value + startIndex è minore di 64 K.The address specified by value + startIndex is less than 64K.

In alternativa-or- Non è stato possibile inizializzare una nuova istanza di String mediante value, supponendo che value sia stato codificato secondo quanto specificato da enc.A new instance of String could not be initialized using value, assuming value is encoded as specified by enc.

value, startIndex e length specificano collettivamente un indirizzo non valido., startIndex, and length collectively specify an invalid address.

Commenti

Nota

Per esempi e informazioni sull'utilizzo complete su questo e altri String overload del costruttore, vedere il String costruttore riepilogo.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Sicurezza

SecurityCriticalAttribute
richiede l'attendibilità totale per il chiamante immediato.requires full trust for the immediate caller. Questo membro non può essere utilizzato da codice parzialmente attendibile o trasparente.This member cannot be used by partially trusted or transparent code.

Si applica a