Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Costruttore String

 

Data di pubblicazione: ottobre 2016

Inizializza una nuova istanza della classe String.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

NomeDescrizione
System_CAPS_pubmethodString(Char*)

Inizializza una nuova istanza della classe String sul valore indicato da uno specifico puntatore a una matrice di caratteri Unicode.

System_CAPS_pubmethodString(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.

System_CAPS_pubmethodString(Char, Int32)

Inizializza una nuova istanza della classe String sul valore indicato da uno specifico carattere Unicode ripetuto un numero precisato di volte.

System_CAPS_pubmethodString(Char[])

Inizializza una nuova istanza della classe String sul valore indicato da una matrice di caratteri Unicode.

System_CAPS_pubmethodString(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.

System_CAPS_pubmethodString(SByte*)

Inizializza una nuova istanza della classe String sul valore indicato da un puntatore a una matrice di interi con segno a 8 bit.

System_CAPS_pubmethodString(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.

System_CAPS_pubmethodString(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.

Costruttori di stringa rientrano in due categorie: privi di parametri di puntatore, mentre quelle con i parametri di puntatore. I costruttori che utilizzano i puntatori non sono conformi a CLS. Inoltre, Visual Basic non supporta l'utilizzo dei puntatori, e in c# il codice che utilizza i puntatori per eseguire in un contesto unsafe. Per altre informazioni, vedere unsafe (Riferimenti per C#).

Per informazioni aggiuntive sulla scelta di un overload, vedere quale metodo chiamato?

String(Char[] value)

Inizializza la nuova istanza sul valore indicato da una matrice di caratteri Unicode. Questo costruttore consente di copiare i caratteri Unicode (esempio).

String(Char[] value, Int32 startIndex, Int32 length)

Inizializza la nuova istanza sul valore indicato da una matrice di caratteri Unicode, una posizione iniziale del carattere all'interno di tale matrice e da una lunghezza (esempio).

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 (esempio).

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'). (example).

Autorizzazione: SecurityCriticalAttribute, richiede l'attendibilità totale per il chiamante immediato. Questo membro non può essere utilizzato da codice parzialmente attendibile o trasparente.

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, una posizione iniziale del carattere all'interno di tale matrice e da una lunghezza. Il costruttore di copia i caratteri Unicode da value a partire dall'indice startIndex e termina in corrispondenza dell'indice startIndex + length – 1 (esempio).

Autorizzazione: SecurityCriticalAttribute, richiede l'attendibilità totale per il chiamante immediato. Questo membro non può essere utilizzato da codice parzialmente attendibile o trasparente.

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. Si presuppone che la matrice rappresentano una stringa codificata utilizzando la tabella codici di sistema corrente (ovvero, la codifica specificata da 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).

Autorizzazione: SecurityCriticalAttribute, richiede l'attendibilità totale per il chiamante immediato. Questo membro non può essere utilizzato da codice parzialmente attendibile o trasparente.

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, da una posizione inizia all'interno di tale matrice e da una lunghezza. Si presuppone che la matrice rappresentano una stringa codificata utilizzando la tabella codici di sistema corrente (ovvero, la codifica specificata da Encoding.Default). Il costruttore elabora i caratteri a partire valore startIndex e fine startIndex + length – 1 (esempio).

Autorizzazione: SecurityCriticalAttribute, richiede l'attendibilità totale per il chiamante immediato. Questo membro non può essere utilizzato da codice parzialmente attendibile o trasparente.

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.

Autorizzazione: SecurityCriticalAttribute, richiede l'attendibilità totale per il chiamante immediato. Questo membro non può essere utilizzato da codice parzialmente attendibile o trasparente.

Ecco un elenco completo dei parametri usati dalla Stringcostruttori che non includono un parametro del puntatore. Per i parametri utilizzati da ogni overload, vedere la sintassi di overload precedente.

Parametro

Tipo

Descrizione

value

Char[]

Matrice di caratteri Unicode.

c

Char

Carattere Unicode.

startIndex

Int32

La posizione iniziale nella value del primo carattere nella stringa di nuovo.

Il valore predefinito: 0

length

Int32

Il numero di caratteri in value da includere nella nuova stringa.

Valore predefinito:Array.Length

count

Int32

Il numero di volte in cui il carattere c viene ripetuta nella stringa di nuovo. Se count è zero, il valore del nuovo oggetto è String.Empty.

Ecco un elenco completo dei parametri usati dalla Stringcostruttori che includono un parametro del puntatore. Per i parametri utilizzati da ogni overload, vedere la sintassi di overload precedente.

Parametro

Tipo

Descrizione

value

Char*

-oppure-

SByte*

Un puntatore a una matrice con terminazione null di caratteri Unicode o una matrice di interi con segno a 8 bit. Se value è null o una matrice vuota, il valore della nuova stringa è String.Empty.

startIndex

Int32

Indice dell'elemento della matrice che definisce il primo carattere nella stringa di nuovo.

Il valore predefinito: 0

length

Int32

Il numero di elementi della matrice da utilizzare per creare la nuova stringa. Se length è zero, il costruttore crea una stringa il cui valore è String.Empty.

Valore predefinito:Array.Length

enc

Encoding

Oggetto che specifica il modo in value viene codificata.

Il valore predefinito: Encoding.Default, o tabella codici ANSI corrente del sistema

Di seguito è riportato un elenco delle eccezioni generate dai costruttori che non includano parametri di puntatore.

Exception

Condizione

Generata dal

ArgumentNullException

value è null.

String(Char[], Int32, Int32)

ArgumentOutOfRangeException

startIndex,length, o count è minore di zero.

-oppure-

La somma di startIndex e length è maggiore del numero di elementi in value.

-oppure-

count è minore di zero.

String(Char, Int32)

String(Char[], Int32, Int32)

Di seguito è riportato un elenco delle eccezioni generate dai costruttori che includono parametri di puntatore.

Exception

Condizione

Generata dal

ArgumentException

valueSpecifica una matrice che contiene un carattere Unicode non valido.

-oppure-

valueo value + startIndexspecifica un indirizzo minore di 64 K.

-oppure-

Un nuovo String istanza potrebbe non essere inizializzata dal value della matrice di byte perché value non utilizza il codice codifica predefinita.

Tutti i costruttori con puntatori.

ArgumentNullException

value è 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.

-oppure-

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.

-oppure-

La lunghezza della nuova stringa è troppo grande da allocare.

Tutti i costruttori con puntatori.

AccessViolationException

value, o value + startIndex + length – 1, specifica un indirizzo non valido.

String(SByte*)

String(SByte*, Int32, Int32)

String(SByte*, Int32, Int32, Encoding)

A

Chiamata o utilizzo

Creare una stringa.

Assegnazione di un valore letterale stringa o una stringa esistente (esempio)

Creare una stringa da un'intera matrice di caratteri.

String(Char[])(example)

Crea un stringa da una parte di una matrice di caratteri.

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

Creare una stringa che si ripete di più volte lo stesso carattere.

String(Char, Int32)(example)

Creare una stringa da un puntatore a una matrice di caratteri wide Unicode.

String(Char*)

Creare una stringa da una parte di una matrice di caratteri wide Unicode tramite il relativo puntatore.

String(Char*, Int32, Int32)

Creare una stringa da C++ char matrice.

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

-oppure-

String(SByte*, Int32, Int32, Encoding)

Creare una stringa di caratteri ASCII.

ASCIIEncoding.GetString

Più diffuse tecnica per la creazione di stringhe a livello di codice è una semplice assegnazione, come illustrato nel in questo esempio. La String classe include anche i quattro tipi di overload del costruttore che consentono di creare stringhe tra i valori seguenti:

  • Da una matrice di caratteri (una matrice di caratteri con codifica UTF-16). È possibile creare un nuovo String oggetto dai caratteri l'intera matrice o una parte di esso. Il String(Char[]) costruttore copia tutti i caratteri nella matrice per la nuova stringa. Il String(Char[], Int32, Int32) costruttore copia i caratteri da indice startIndex all'indice startIndex + length – 1 per la nuova stringa. Se length è zero, il valore della nuova stringa è String.Empty.

    Se il codice crea ripetutamente le stringhe che presentano lo stesso valore, è possibile migliorare le prestazioni dell'applicazione utilizzando un metodo alternativo di creazione di stringhe. Per ulteriori informazioni, vedere la gestione delle stringhe ricorrenti.

  • Da un singolo carattere che è duplicato zero, a una o più volte, tramite il String(Char, Int32) costruttore. Se count è zero, il valore della nuova stringa è String.Empty.

  • Da un puntatore a una matrice di caratteri con terminazione null, tramite il String(Char*) o String(Char*, Int32, Int32) costruttore. L'intera matrice o un intervallo specificato può essere utilizzato per inizializzare la stringa. Il costruttore di copia di una sequenza di caratteri Unicode a partire dal puntatore specificato o dal puntatore specificato più startIndex e continuando fino alla fine della matrice o per length caratteri. Se value è un puntatore null o length è zero, il costruttore crea una stringa il cui valore è 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. Questa condizione potrebbe causare una violazione di accesso.

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

    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. In C++, ciò significa che la matrice di caratteri deve essere definito come gestito Chartipo [] o non gestitowchar_ttipo [].

    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. Inoltre, sul processore Intel Itanium, le chiamate alString(Char*, Int32, Int32)costruttore potrebbe generare un DataMisalignedException eccezione. In questo caso, chiamare il String(Char[], Int32, Int32) invece.

  • Da un puntatore a una matrice di byte con segno. L'intera matrice o un intervallo specificato può essere utilizzato per inizializzare la stringa. La sequenza di byte può essere interpretata utilizzando la tabella codici predefinita di codifica, o una codifica può essere specificata nella chiamata al costruttore. Se il costruttore tenta di creare un'istanza di una stringa da un'intera matrice che non è con terminazione null o se l'intervallo della matrice da value + startIndex a value + startIndex + length -1 è all'esterno della memoria allocata per la matrice, il comportamento di questo costruttore è dipendente dal sistema e potrebbe verificarsi una violazione di accesso.

    I tre costruttori che includono una matrice di byte con segno come un parametro sono progettati principalmente per convertire un C++ char matrice in una stringa, come illustrato in questo esempio:

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

    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 utilizzando la tabella codici ANSI predefinita, chiamare questi costruttori con matrici di byte identici possono creare le stringhe che presentano valori diversi in sistemi diversi.

Le applicazioni che analizzano o decodificano flussi di testo spesso utilizzano il String(Char[], Int32, Int32) costruttore o StringBuilder.Append(Char[], Int32, Int32) metodo per convertire le sequenze di caratteri in una stringa. Creazione di nuove stringhe più volte con lo stesso valore invece di creare e riutilizzare una stringa costituisce uno spreco di memoria. Se si è probabilmente di creare più volte lo stesso valore di stringa chiamando il String(Char[], Int32, Int32) costruttore, anche se non si conosce anticipo quale potrebbero essere tali valori di stringa identica, è possibile usare invece una tabella di ricerca.

Si supponga, ad esempio, leggere e analizzare un flusso di caratteri da un file che contiene tag e attributi XML. Quando si utilizza il flusso, si verifica ripetutamente determinati token (sequenze di caratteri che hanno un significato simbolico). Token equivalenti per le stringhe "0", "1", "true" e "false" è probabile che si verificano di frequente in un flusso XML.

Anziché convertire ciascun token in una nuova stringa, è possibile creare un System.Xml.NameTable oggetto per le stringhe che si ripetono frequentemente. Il NameTable oggetto migliora le prestazioni, poiché recupera le stringhe archiviate senza allocare memoria temporanea. Quando si verifica un token, utilizzare il NameTable.Get(Char[], Int32, Int32) metodo per recuperare il token dalla tabella. Se il token esiste, il metodo restituisce la stringa corrispondente. Se il token non esiste, utilizzare il NameTable.Add(Char[], Int32, Int32) metodo per inserire il token nella tabella e per ottenere la stringa corrispondente.

L'esempio seguente crea una nuova stringa mediante l'assegnazione di un valore letterale stringa. Crea una seconda stringa assegnandogli il valore della prima stringa. Questi sono i due modi più comuni per creare un'istanza di un nuovo String oggetto.

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.

Nell'esempio seguente viene illustrato come creare un nuovo String oggetto da una matrice di caratteri.

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

Nell'esempio seguente viene illustrato come creare un nuovo String oggetto da una parte di una matrice di caratteri e come creare un nuovo String oggetto che contiene più occorrenze di un singolo carattere.

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

Nell'esempio seguente viene illustrato come creare un nuovo String oggetto da un puntatore a una matrice di caratteri. Nell'esempio c# debba essere compilata usando la /unsafe opzione del compilatore.

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!

Nell'esempio seguente vengono esaminati gli elementi di una matrice di caratteri per un punto o un punto esclamativo. Se viene trovato uno, crea un'istanza di una stringa di caratteri nella matrice che precedono il simbolo di punteggiatura. In caso contrario, viene creata un'istanza di una stringa con l'intero contenuto della matrice. Nell'esempio c# deve essere compilata usando la /unsafe opzione del compilatore.

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

Nell'esempio seguente viene illustrato come è possibile creare un'istanza di String classe con il String(SByte*) costruttore.

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

.NET Framework

Tutti gli overload sono supportati in: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Tutti gli overload sono supportati in: 4, 3.5 SP1

Libreria di classi portabile

Tutti gli overload senza un SByte* parametro sono supportati

.NET per app di Windows Store

Tutti gli overload senza un SByte* parametro sono supportati in: Windows 8

Torna all'inizio
Mostra: