String Konstruktoren

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Initialisiert eine neue Instanz der String-Klasse.

Überlädt

String(Char*)	Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch einen angegebenen Zeiger auf ein Array von Unicode-Zeichen bestimmt wird.
String(Char[])	Initialisiert eine neue Instanz der String-Klasse mit den im angegebenen Zeichenarray genannten Unicode-Zeichen.
String(ReadOnlySpan<Char>)	Initialisiert eine neue Instanz der String-Klasse mit den im angegebenen schreibgeschützten Bereich genannten Unicode-Zeichen.
String(SByte*)	Initialisiert eine neue Instanz der String-Klasse mit dem durch einen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen angegebenen Wert.
String(Char, Int32)	Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch ein angegebenes so oft wie angegeben wiederholtes Unicode-Zeichen bestimmt wird.
String(Char*, Int32, Int32)	Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch einen angegebenen Zeiger auf ein Array von Unicode-Zeichen, durch die Position des ersten Zeichens innerhalb dieses Arrays und durch eine Länge bestimmt wird.
String(Char[], Int32, Int32)	Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch ein Array von Unicode-Zeichen, die Position des ersten Zeichens innerhalb dieses Arrays und eine Länge bestimmt wird.
String(SByte*, Int32, Int32)	Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch einen angegebenen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen, die Startposition innerhalb dieses Arrays und die Länge angegeben wird.
String(SByte*, Int32, Int32, Encoding)	Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch einen angegebenen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen, die Startposition innerhalb dieses Arrays, eine Länge und ein Encoding-Objekt angegeben wird.

Hinweise

In diesem Abschnitt

Syntax überladener Konstruktoren
Parameter
Ausnahmen
Welche Methode rufe ich auf?
Erstellen von Zeichenfolgen
Verarbeiten sich wiederholender Zeichenfolgen

Beispiele für das Instanziieren von Zeichenfolgen:

Verwenden der Zeichenfolgenzuweisung
Verwenden eines Zeichenarrays
Verwenden eines Teils eines Zeichenarrays und Wiederholen eines einzelnen Zeichens
Verwenden eines Zeigers auf ein Zeichenarray
Verwenden eines Zeigers und eines Bereichs eines Arrays
Verwenden eines Zeigers auf ein signiertes Bytearray

Syntax überladener Konstruktoren

Zeichenfolgenkonstruktoren lassen sich in zwei Kategorien unterteilen: Konstruktoren ohne Zeigerparameter und Konstruktoren mit Zeigerparametern. Die Konstruktoren, die Zeiger verwenden, sind nicht CLS-kompatibel. Darüber hinaus unterstützt Visual Basic die Verwendung von Zeigern nicht, und C# erfordert Code, der Zeiger verwendet, um in einem unsicheren Kontext ausgeführt zu werden. Weitere Informationen finden Sie unter unsafe.

Weitere Anleitungen zum Auswählen einer Überladung finden Sie unter Welche Methode rufe ich auf?.

String(Char[] value)
Initialisiert die neue -Instanz mit dem Wert, der durch ein Array von Unicode-Zeichen angegeben wird. Dieser Konstruktor kopiert Unicode-Zeichen(Beispiel).

String(Char[] value, Int32 startIndex, Int32 length)
Initialisiert die neue -Instanz mit dem Wert, der durch ein Array von Unicode-Zeichen, eine Anfangszeichenposition innerhalb dieses Arrays und eine Länge (z. B. ) angegebenwird.

String(Char c, Int32 count)
Initialisiert die neue -Instanz mit dem Wert, der durch ein angegebenes Unicode-Zeichen angegeben wird, das eine angegebene Anzahl von Wiederholungen wiederholt(z. B.).

String(char* value)
(Nicht CLS-kompatibel) Initialisiert die neue -Instanz mit dem Wert, der durch einen Zeiger auf ein Array von Unicode-Zeichen angegeben wird, das mit einem NULL-Zeichen beendet wird (U+0000 oder '\0'). (Beispiel)

Berechtigung: SecurityCriticalAttribute erfordert volle Vertrauenswürdigkeit für den unmittelbaren Aufrufer. Dieser Member kann nicht von teilweise vertrauenswürdigen oder transparenten Code verwendet werden.

String(char* value, Int32 startIndex, Int32 length)
(Nicht CLS-kompatibel) Initialisiert die neue -Instanz mit dem Wert, der durch einen Zeiger auf ein Array von Unicode-Zeichen, eine Anfangszeichenposition innerhalb dieses Arrays und eine Länge angegeben wird. Der Konstruktor kopiert die Unicode-Zeichen vom Anfang am Index bis zum Index value startIndex - startIndex + length 1(Beispiel).

String(SByte* value)
(Nicht CLS-kompatibel) Initialisiert die neue -Instanz mit dem Wert, der durch einen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen angegeben wird. Es wird davon ausgegangen, dass das Array eine mit der aktuellen Systemcodepage codierte Zeichenfolge (d. h. die von angegebene Codierung) Encoding.Default repräsentiert. Der Konstruktor verarbeitet Zeichen von der vom Zeiger angegebenen Position bis zum Erreichen eines NULL-Zeichens value (0x00)(Beispiel).

String(SByte* value, Int32 startIndex, Int32 length)
(Nicht CLS-kompatibel) Initialisiert die neue -Instanz mit dem Wert, der durch einen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen, eine Anfangsposition innerhalb dieses Arrays und eine Länge angegeben wird. Es wird davon ausgegangen, dass das Array eine mit der aktuellen Systemcodepage codierte Zeichenfolge (d. h. die von angegebene Codierung) Encoding.Default repräsentiert. Der Konstruktor verarbeitet Zeichen ab dem Wert ab startIndex und dem Ende bei – startIndex + length 1(Beispiel).

String(SByte* value, Int32 startIndex, Int32 length, Encoding enc)
(Nicht CLS-kompatibel) Initialisiert die neue -Instanz mit dem Wert, der durch einen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen, eine Anfangsposition innerhalb dieses Arrays, eine Länge und ein -Objekt angegeben Encoding wird.

Parameter

Im Folgenden finden Sie eine vollständige Liste der Parameter, die von Konstruktoren verwendet String werden, die keinen Zeigerparameter enthalten. Die von jeder Überladung verwendeten Parameter finden Sie in der obigen Überladungssyntax.

Parameter	Typ	BESCHREIBUNG
`value`	Char[]	Ein Array von Unicode-Zeichen.
`c`	Char	Ein Unicode-Zeichen.
`startIndex`	Int32	Die Anfangsposition in `value` des ersten Zeichens in der neuen Zeichenfolge. Standardwert: 0
`length`	Int32	Die Anzahl der Zeichen in `value` , die in die neue Zeichenfolge enthalten sein soll. Standardwert: Array.Length
`count`	Int32	Die Anzahl der Wiederholungen des `c` Zeichens in der neuen Zeichenfolge. Wenn `count` 0 (null) ist, ist der Wert des neuen -Objekts String.Empty .

Im Folgenden finden Sie eine vollständige Liste der Parameter, die von String Konstruktoren verwendet werden, die einen Zeigerparameter enthalten. Die von jeder Überladung verwendeten Parameter finden Sie in der obigen Überladungssyntax.

Parameter	Typ	BESCHREIBUNG
`value`	Char* - oder - SByte*	Ein Zeiger auf ein auf NULL terminiertes Array von Unicode-Zeichen oder ein Array von 8-Bit-Ganzzahlen mit Vorzeichen. Wenn `value` oder `null` ein leeres Array ist, ist der Wert der neuen Zeichenfolge String.Empty .
`startIndex`	Int32	Der Index des Arrayelements, das das erste Zeichen in der neuen Zeichenfolge definiert. Standardwert: 0
`length`	Int32	Die Anzahl der Arrayelemente, die zum Erstellen der neuen Zeichenfolge verwendet werden. Wenn length 0 (null) ist, erstellt der Konstruktor eine Zeichenfolge, deren Wert String.Empty ist. Standardwert: Array.Length
`enc`	Encoding	Ein -Objekt, das angibt, wie `value` das Array codiert wird. Standardwert: Encoding.Default oder die aktuelle ANSI-Codepage des Systems

Ausnahmen

Im Folgenden finden Sie eine Liste der Ausnahmen, die von Konstruktoren ausgelöst werden, die keine Zeigerparameter enthalten.

Ausnahme	Bedingung	Ausgelöst von
ArgumentNullException	`value` ist `null`.	String(Char[], Int32, Int32)
ArgumentOutOfRangeException	`startIndex`, `length` oder ist kleiner als `count` 0 (null). - oder - Die Summe von `startIndex` und `length` ist größer als die Anzahl von Elementen in `value`. - oder - `count` ist kleiner als Null.	String(Char, Int32) String(Char[], Int32, Int32)

Im Folgenden finden Sie eine Liste der Ausnahmen, die von Konstruktoren ausgelöst werden, die Zeigerparameter enthalten.

Ausnahme	Bedingung	Ausgelöst von
ArgumentException	`value` gibt ein Array an, das ein ungültiges Unicode-Zeichen enthält. - oder - `value`oder `value` + `startIndex` gibt eine Adresse an, die kleiner als 64K ist. - oder - Eine neue String -Instanz konnte nicht aus dem `value` Bytearray initialisiert werden, da `value` nicht die Standardcodierung der Codepage verwendet.	Alle Konstruktoren mit Zeigern.
ArgumentNullException	`value` ist NULL.	String(SByte) String(SByte, Int32, Int32) String(SByte*, Int32, Int32, Encoding)
ArgumentOutOfRangeException	Der aktuelle Prozess hat keinen Lesezugriff auf alle adressierten Zeichen. - oder - `startIndex` oder `length` ist kleiner als 0 (null), `value` + `startIndex` verursacht einen Zeigerüberlauf oder der aktuelle Prozess hat keinen Lesezugriff auf alle adressierten Zeichen. - oder - Die Länge der neuen Zeichenfolge ist zu groß für die Zuordnung.	Alle Konstruktoren mit Zeigern.
AccessViolationException	`value`oder `value` + `startIndex` + `length` – 1 gibt eine ungültige Adresse an.	String(SByte) String(SByte, Int32, Int32) String(SByte*, Int32, Int32, Encoding)

Welche Methode rufe ich auf?

Beschreibung	Aufrufen oder Verwenden
Erstellen Sie eine Zeichenfolge.	Zuweisung aus einem Zeichenfolgenliteral oder einer vorhandenen Zeichenfolge (Beispiel)
Erstellen Sie eine Zeichenfolge aus einem gesamten Zeichenarray.	String(Char[]) (Beispiel)
Erstellen Sie eine Zeichenfolge aus einem Teil eines Zeichenarrays.	String(Char[], Int32, Int32) (Beispiel)
Erstellen Sie eine Zeichenfolge, die dasselbe Zeichen mehrmals wiederholt.	String(Char, Int32) (Beispiel)
Erstellen Sie eine Zeichenfolge aus einem Zeiger auf ein Unicode- oder Breitzeichenarray.	String(Char*)
Erstellen Sie eine Zeichenfolge aus einem Teil eines Unicode- oder Breitzeichenarrays mithilfe seines Zeigers.	String(Char*, Int32, Int32)
Erstellen Sie eine Zeichenfolge aus einem `char` C++-Array.	String(SByte), String(SByte, Int32, Int32) - oder - String(SByte*, Int32, Int32, Encoding)
Erstellen Sie eine Zeichenfolge aus ASCII-Zeichen.	ASCIIEncoding.GetString

Erstellen von Zeichenfolgen

Das am häufigsten verwendete Verfahren zum programmgesteuerten Erstellen von Zeichenfolgen ist die einfache Zuweisung, wie in diesem Beispiel veranschaulicht. Die String -Klasse enthält auch vier Typen von Konstruktorüberladungen, mit denen Sie Zeichenfolgen aus den folgenden Werten erstellen können:

Aus einem Zeichenarray (ein Array von UTF-16-codierten Zeichen). Sie können ein neues -Objekt aus den Zeichen im gesamten Array oder String einem Teil davon erstellen. Der String(Char[]) Konstruktor kopiert alle Zeichen im Array in die neue Zeichenfolge. Der String(Char[], Int32, Int32) Konstruktor kopiert die Zeichen aus dem Index in den Index – startIndex startIndex + length 1 in die neue Zeichenfolge. Wenn length 0 (null) ist, ist der Wert der neuen Zeichenfolge String.Empty .

Wenn Ihr Code wiederholt Zeichenfolgen instanziiert, die denselben Wert haben, können Sie die Anwendungsleistung verbessern, indem Sie eine alternative Methode zum Erstellen von Zeichenfolgen verwenden. Weitere Informationen finden Sie unter Behandeln sich wiederholender Zeichenfolgen.
Aus einem einzelnen Zeichen, das mithilfe des Konstruktors null, einmal oder mehrmals dupliziert String(Char, Int32) wird. Wenn count 0 (null) ist, ist der Wert der neuen Zeichenfolge String.Empty .
Von einem Zeiger auf ein auf NULL beendetes Zeichenarray mithilfe des -Konstruktors String(Char*) oder des String(Char*, Int32, Int32) -Konstruktors. Zum Initialisieren der Zeichenfolge kann entweder das gesamte Array oder ein angegebener Bereich verwendet werden. Der Konstruktor kopiert eine Sequenz von Unicode-Zeichen, beginnend mit dem angegebenen Zeiger oder aus dem angegebenen Zeiger plus und bis zum Ende des Arrays oder startIndex für length Zeichen. Wenn value ein NULL-Zeiger oder length 0 (null) ist, erstellt der Konstruktor eine Zeichenfolge, deren Wert String.Empty ist. Wenn der Kopiervorgang an das Ende des Arrays fortgesetzt wird und das Array nicht auf NULL endet, ist das Konstruktorverhalten systemabhängig. Eine solche Bedingung kann eine Zugriffsverletzung verursachen.

Wenn das Array eingebettete NULL-Zeichen (U+0000 oder '\0') enthält und die Überladung aufgerufen wird, enthält die Zeichenfolgeninstanz Zeichen einschließlich eingebetteter String(Char*, Int32, Int32) length NULL-Werte. Das folgende Beispiel zeigt, was geschieht, wenn ein Zeiger auf ein Array von 10 Elementen, das zwei NULL-Zeichen enthält, an die -Methode übergeben String(Char*, Int32, Int32) wird. Da die Adresse der Anfang des Arrays ist und alle Elemente im Array der Zeichenfolge hinzugefügt werden sollen, instanziiert der Konstruktor eine Zeichenfolge mit zehn Zeichen, einschließlich zwei eingebetteter NULL-Werte. Wenn andererseits dasselbe Array an den Konstruktor übergeben wird, ist das Ergebnis eine Zeichenfolge mit vier Zeichen, die das erste String(Char*) NULL-Zeichen nicht enthält.
```
using namespace System;

void main()
{
   wchar_t chars[] = { L'a', L'b', L'c', L'd', L'\0', L'A', L'B', 
                       L'C', L'D', L'\0' };
   Char* chPtr = chars;
   String^ s = gcnew String(chPtr, 0, 
                            sizeof(chars) / sizeof (wchar_t));            
   for each (Char ch in s)
      Console::Write("{0:X4} ", Convert::ToUInt16(ch));
   Console::WriteLine();
   
   s = gcnew String(chPtr);         
   
   for each (Char ch in s)
      Console::Write("{0:X4} ", Convert::ToUInt16(ch));
   Console::WriteLine();    
}
// The example displays the following output:
//       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
//       0061 0062 0063 0064
```
```
using System;

public class Example
{
   public unsafe static void Main()
   {
      char[] chars = { 'a', 'b', 'c', 'd', '\0', 'A', 'B', 'C', 'D', '\0' };
      string s = null;
      
      fixed(char* chPtr = chars) {
         s = new string(chPtr, 0, chars.Length);            
      } 

      foreach (var ch in s)
         Console.Write($"{(ushort)ch:X4} ");
      Console.WriteLine();
      
      fixed(char* chPtr = chars) {
         s = new string(chPtr);         
      }
      
      foreach (var ch in s)
         Console.Write($"{(ushort)ch:X4} ");
      Console.WriteLine();    
   }
}
// The example displays the following output:
//       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
//       0061 0062 0063 0064
```
Das Array muss Unicode-Zeichen enthalten. In C++ bedeutet dies, dass das Zeichenarray entweder als verwalteter []-Typ oder als Char nicht verwalteter wchar_t []-Typ definiert werden muss.

Wenn die Überladung aufgerufen wird und das Array nicht auf NULL endet, oder wenn die Überladung aufgerufen wird und -1 einen Bereich enthält, der außerhalb des für die Zeichensequenz zugeordneten Arbeitsspeichers liegt, ist das Verhalten des Konstruktors String(Char*) String(Char*, Int32, Int32) startIndex + systemabhängig, und es kann zu einer Zugriffsverletzung length kommen.
Von einem Zeiger auf ein signiertes Bytearray. Zum Initialisieren der Zeichenfolge kann entweder das gesamte Array oder ein angegebener Bereich verwendet werden. Die Bytesequenz kann mithilfe der Standardcodierung der Codepage interpretiert werden, oder eine Codierung kann im Konstruktoraufruf angegeben werden. Wenn der Konstruktor versucht, eine Zeichenfolge aus einem gesamten Array zu instanziieren, das nicht auf NULL endet, oder wenn der Bereich des Arrays von bis -1 außerhalb des für das Array zugeordneten Arbeitsspeichers liegt, ist das Verhalten dieses Konstruktors value + startIndex value + startIndex + length systemabhängig, und es kann zu einer Zugriffsverletzung kommen.

Die drei Konstruktoren, die ein Signiert-Bytearray als Parameter enthalten, sind in erster Linie für die Konvertierung eines C++-Arrays in eine Zeichenfolge konzipiert, wie char im folgenden Beispiel gezeigt:
```
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
```
Wenn das Array NULL-Zeichen ("\0") oder Bytes enthält, deren Wert 0 ist und die Überladung aufgerufen wird, enthält die Zeichenfolgeninstanz Zeichen einschließlich eingebetteter String(SByte*, Int32, Int32) length NULL-Werte. Das folgende Beispiel zeigt, was geschieht, wenn ein Zeiger auf ein Array von 10 Elementen, das zwei NULL-Zeichen enthält, an die -Methode übergeben String(SByte*, Int32, Int32) wird. Da die Adresse der Anfang des Arrays ist und alle Elemente im Array der Zeichenfolge hinzugefügt werden sollen, instanziiert der Konstruktor eine Zeichenfolge mit zehn Zeichen, einschließlich zwei eingebetteter NULL-Werte. Wenn andererseits dasselbe Array an den Konstruktor übergeben wird, ist das Ergebnis eine Zeichenfolge mit vier Zeichen, die das erste String(SByte*) NULL-Zeichen nicht enthält.
```
using namespace System;

void main()
{
   char bytes[] = { 0x61, 0x62, 0x063, 0x064, 0x00, 0x41, 0x42,0x43, 
                    0x44, 0x00 };
   
   char* bytePtr = bytes;
   String^ s = gcnew String(bytePtr, 0, sizeof(bytes) / sizeof (char));
   
   for each (Char ch in s)
      Console::Write("{0:X4} ", Convert::ToUInt16(ch));
   
   Console::WriteLine();
   
   s = gcnew String(bytePtr);

   for each (Char ch in s)
      Console::Write("{0:X4} ", Convert::ToUInt16(ch));
   Console::WriteLine();       
}
// The example displays the following output:
//      0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
//      0061 0062 0063 0064
```
```
using System;

public class Example
{
   public unsafe static void Main()
   {
      sbyte[] bytes = { 0x61, 0x62, 0x063, 0x064, 0x00, 0x41, 0x42, 0x43, 0x44, 0x00 };
      
      string s = null;
      fixed (sbyte* bytePtr = bytes) {
         s = new string(bytePtr, 0, bytes.Length);
      }
      
      foreach (var ch in s)
         Console.Write($"{(ushort)ch:X4} ");
      
      Console.WriteLine();    

      fixed(sbyte* bytePtr = bytes) {
         s = new string(bytePtr);         
      }
      
      foreach (var ch in s)
         Console.Write($"{(ushort)ch:X4} ");
      Console.WriteLine();    
   }
}
// The example displays the following output:
//       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
//       0061 0062 0063 0064
```
Da die Konstruktoren und mithilfe der STANDARDMÄßIGEN ANSI-Codepage interpretieren, kann der Aufruf dieser Konstruktoren mit identischen String(SByte*) Bytearrays Zeichenfolgen erstellen, die auf unterschiedlichen String(SByte*, Int32, Int32) value Systemen unterschiedliche Werte haben.

Verarbeiten sich wiederholender Zeichenfolgen

Apps, die Textstreams analysieren oder decodieren, verwenden häufig den Konstruktor oder die -Methode, um Zeichensequenzen in String(Char[], Int32, Int32) StringBuilder.Append(Char[], Int32, Int32) eine Zeichenfolge zu konvertieren. Das wiederholte Erstellen neuer Zeichenfolgen mit dem gleichen Wert, anstatt eine Zeichenfolge zu erstellen und wieder zu verwenden, verschwendet Arbeitsspeicher. Wenn Sie wahrscheinlich den gleichen Zeichenfolgenwert wiederholt durch Aufrufen des Konstruktors erstellen, können Sie stattdessen eine Nachschlagetabelle verwenden, auch wenn Sie nicht im Voraus wissen, was diese identischen Zeichenfolgenwerte String(Char[], Int32, Int32) sein können.

Angenommen, Sie lesen und analysieren einen Datenstrom von Zeichen aus einer Datei, die XML-Tags und -Attribute enthält. Wenn Sie den Stream analysieren, stoßen Sie wiederholt auf bestimmte Token (d. h. Sequenzen von Zeichen mit symbolischer Bedeutung). Token, die den Zeichenfolgen "0", "1", "true" und "false" entsprechen, treten wahrscheinlich häufig in einem XML-Stream auf.

Anstatt jedes Token in eine neue Zeichenfolge zu konvertieren, können Sie ein -Objekt erstellen, System.Xml.NameTable das häufig auftretende Zeichenfolgen enthält. Das NameTable -Objekt verbessert die Leistung, da es gespeicherte Zeichenfolgen abruft, ohne temporären Arbeitsspeicher zuzuordnen. Wenn sie auf ein Token stoßen, verwenden Sie die NameTable.Get(Char[], Int32, Int32) -Methode, um das Token aus der Tabelle abzurufen. Wenn das Token vorhanden ist, gibt die Methode die entsprechende Zeichenfolge zurück. Wenn das Token nicht vorhanden ist, verwenden Sie die -Methode, um das Token in die Tabelle einfüge NameTable.Add(Char[], Int32, Int32) und die entsprechende Zeichenfolge abzurufen.

Beispiel 1: Verwenden der Zeichenfolgenzuweisung

Im folgenden Beispiel wird eine neue Zeichenfolge erstellt, indem ihr ein Zeichenfolgenliteral zugewiesen wird. Sie erstellt eine zweite Zeichenfolge, indem der Wert der ersten Zeichenfolge zugewiesen wird. Dies sind die beiden gängigsten Methoden zum Instanziieren eines neuen String Objekts.

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.

Beispiel 2: Verwenden eines Zeichenarrays

Im folgenden Beispiel wird veranschaulicht, wie ein neues -Objekt String aus einem Zeichenarray erstellt wird.

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

Beispiel 3: Verwenden eines Teils eines Zeichenarrays und Wiederholen eines einzelnen Zeichens

Im folgenden Beispiel wird veranschaulicht, wie ein neues -Objekt aus einem Teil eines Zeichenarrays erstellt wird und wie ein neues -Objekt erstellt wird, das mehrere Vorkommen eines String String einzelnen Zeichens enthält.

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

Beispiel 4: Verwenden eines Zeigers auf ein Zeichenarray

Im folgenden Beispiel wird veranschaulicht, wie ein neues -Objekt aus String einem Zeiger auf ein Array von Zeichen erstellt wird. Das C#-Beispiel muss mithilfe des /unsafe Compilerschalters kompiliert werden.

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!

Beispiel 5: Instanziieren einer Zeichenfolge aus einem Zeiger und einem Arraybereich

Im folgenden Beispiel werden die Elemente eines Zeichenarrays für einen Punkt oder ein Ausrufezeichen untersucht. Wenn eine gefunden wird, wird eine Zeichenfolge aus den Zeichen im Array instanziiert, die dem Interpunktionssymbol voran stehen. Wenn nicht, wird eine Zeichenfolge mit dem gesamten Inhalt des Arrays instanziiert. Das C#-Beispiel muss mit dem Compilerschalter /unsafe kompiliert werden.

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

Beispiel 6: Instanziieren einer Zeichenfolge von einem Zeiger auf ein signiertes Bytearray

Im folgenden Beispiel wird veranschaulicht, wie Sie eine Instanz der -Klasse String mit dem Konstruktor erstellen String(SByte*) können.

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

String(Char*)

Wichtig

Diese API ist nicht CLS-kompatibel.

Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch einen angegebenen Zeiger auf ein Array von Unicode-Zeichen bestimmt wird.

public:
 String(char* value);

[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public String (char* value);

[System.CLSCompliant(false)]
public String (char* value);

[<System.CLSCompliant(false)>]
[<System.Security.SecurityCritical>]
new string : nativeptr<char> -> string

[<System.CLSCompliant(false)>]
new string : nativeptr<char> -> string

Parameter

value: Char*

Ein Zeiger auf ein mit Null endendes Array von Unicode-Zeichen.

Attribute: CLSCompliantAttribute SecurityCriticalAttribute

Ausnahmen

ArgumentOutOfRangeException

Der aktuelle Prozess hat keinen Lesezugriff auf alle adressierten Zeichen.

ArgumentException

value gibt ein Array an, das ein ungültiges Unicode-Zeichen enthält, oder value gibt eine Adresse kleiner als 64000 an.

Hinweise

Hinweis

Beispiele und umfassende Verwendungsinformationen zu dieser und anderen Konstruktorüberladungen String finden Sie in der String Konstruktorzusammenfassung.

Gilt für:

String(Char[])

Initialisiert eine neue Instanz der String-Klasse mit den im angegebenen Zeichenarray genannten Unicode-Zeichen.

public:
 String(cli::array <char> ^ value);

public String (char[] value);

public String (char[]? value);

new string : char[] -> string

Public Sub New (value As Char())

Parameter

value: Char[]

Ein Array von Unicode-Zeichen.

Hinweise

Hinweis

Beispiele und umfassende Informationen zur Verwendung dieser und anderer String Konstruktorüberladungen finden Sie in der String Konstruktorzusammenfassung.

Gilt für:

String(ReadOnlySpan<Char>)

Initialisiert eine neue Instanz der String-Klasse mit den im angegebenen schreibgeschützten Bereich genannten Unicode-Zeichen.

public:
 String(ReadOnlySpan<char> value);

public String (ReadOnlySpan<char> value);

new string : ReadOnlySpan<char> -> string

Public Sub New (value As ReadOnlySpan(Of Char))

Parameter

value: ReadOnlySpan<Char>

Ein schreibgeschützter Bereich von Unicode-Zeichen.

Gilt für:

String(SByte*)

Wichtig

Diese API ist nicht CLS-kompatibel.

Initialisiert eine neue Instanz der String-Klasse mit dem durch einen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen angegebenen Wert.

public:
 String(System::SByte* value);

[System.CLSCompliant(false)]
public String (sbyte* value);

public String (sbyte* value);

[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public String (sbyte* value);

[<System.CLSCompliant(false)>]
new string : nativeptr<sbyte> -> string

new string : nativeptr<sbyte> -> string

[<System.CLSCompliant(false)>]
[<System.Security.SecurityCritical>]
new string : nativeptr<sbyte> -> string

Parameter

value: SByte*

Ein Zeiger auf ein mit NULL endendes Array von 8-Bit-Ganzzahlen mit Vorzeichen. Die Ganzzahlen werden mit der aktuellen Systemcodeseiten-Codierung interpretiert (d.h. der durch Default angegebenen Codierung).

Attribute: CLSCompliantAttribute SecurityCriticalAttribute

Ausnahmen

ArgumentNullException

value ist null.

ArgumentException

Eine neue Instanz von String konnte nicht mit value initialisiert werden, wobei angenommen wurde, dass value in ANSI codiert ist.

ArgumentOutOfRangeException

Die Länge der neuen zu initialisierenden Zeichenfolge, die durch das NULL-Abschlusszeichen von value bestimmt wird, ist zu groß für die Zuordnung.

AccessViolationException

value gibt eine ungültige Adresse an.

Hinweise

Hinweis

Beispiele und umfassende Informationen zur Verwendung dieser und anderer String Konstruktorüberladungen finden Sie in der String Konstruktorzusammenfassung.

Gilt für:

String(Char, Int32)

Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch ein angegebenes so oft wie angegeben wiederholtes Unicode-Zeichen bestimmt wird.

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)

Parameter

c: Char

Ein Unicode-Zeichen.

count: Int32

Die Anzahl des Vorkommens von c.

Ausnahmen

ArgumentOutOfRangeException

count ist kleiner als Null.

Hinweise

Hinweis

Beispiele und umfassende Informationen zur Verwendung dieser und anderer String Konstruktorüberladungen finden Sie in der String Konstruktorzusammenfassung.

Gilt für:

String(Char*, Int32, Int32)

Wichtig

Diese API ist nicht CLS-kompatibel.

Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch einen angegebenen Zeiger auf ein Array von Unicode-Zeichen, durch die Position des ersten Zeichens innerhalb dieses Arrays und durch eine Länge bestimmt wird.

public:
 String(char* value, int startIndex, int length);

[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public String (char* value, int startIndex, int length);

[System.CLSCompliant(false)]
public String (char* value, int startIndex, int length);

[<System.CLSCompliant(false)>]
[<System.Security.SecurityCritical>]
new string : nativeptr<char> * int * int -> string

[<System.CLSCompliant(false)>]
new string : nativeptr<char> * int * int -> string

Parameter

value: Char*

Ein Zeiger auf ein Array von Unicode-Zeichen.

startIndex: Int32

Die Anfangsposition in value.

length: Int32

Die Anzahl der aus value zu verwendenden Zeichen.

Attribute: CLSCompliantAttribute SecurityCriticalAttribute

Ausnahmen

ArgumentOutOfRangeException

startIndex oder length ist kleiner als 0 (null), value + startIndex verursacht einen Zeigerüberlauf oder der aktuelle Prozess hat keinen Lesezugriff auf alle adressierten Zeichen.

ArgumentException

value gibt ein Array an, das ein ungültiges Unicode-Zeichen enthält, oder value + startIndex gibt eine Adresse kleiner als 64000 an.

Hinweise

Hinweis

Beispiele und umfassende Informationen zur Verwendung dieser und anderer String Konstruktorüberladungen finden Sie in der String Konstruktorzusammenfassung.

Gilt für:

String(Char[], Int32, Int32)

Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch ein Array von Unicode-Zeichen, die Position des ersten Zeichens innerhalb dieses Arrays und eine Länge bestimmt wird.

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)

Parameter

value: Char[]

Ein Array von Unicode-Zeichen.

startIndex: Int32

Die Anfangsposition in value.

length: Int32

Die Anzahl der aus value zu verwendenden Zeichen.

Ausnahmen

ArgumentNullException

value ist null.

ArgumentOutOfRangeException

startIndex oder length ist kleiner als 0.

- oder -

Die Summe von startIndex und length ist größer als die Anzahl von Elementen in value.

Hinweise

Hinweis

Beispiele und umfassende Informationen zur Verwendung dieser und anderer String Konstruktorüberladungen finden Sie in der String Konstruktorzusammenfassung.

Gilt für:

String(SByte*, Int32, Int32)

Wichtig

Diese API ist nicht CLS-kompatibel.

Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch einen angegebenen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen, die Startposition innerhalb dieses Arrays und die Länge angegeben wird.

public:
 String(System::SByte* value, int startIndex, int length);

[System.CLSCompliant(false)]
public String (sbyte* value, int startIndex, int length);

public String (sbyte* value, int startIndex, int length);

[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public String (sbyte* value, int startIndex, int length);

[<System.CLSCompliant(false)>]
new string : nativeptr<sbyte> * int * int -> string

new string : nativeptr<sbyte> * int * int -> string

[<System.CLSCompliant(false)>]
[<System.Security.SecurityCritical>]
new string : nativeptr<sbyte> * int * int -> string

Parameter

value: SByte*

Ein Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen. Die Ganzzahlen werden mit der aktuellen Systemcodeseiten-Codierung interpretiert (d.h. der durch Default angegebenen Codierung).

startIndex: Int32

Die Anfangsposition in value.

length: Int32

Die Anzahl der aus value zu verwendenden Zeichen.

Attribute: CLSCompliantAttribute SecurityCriticalAttribute

Ausnahmen

ArgumentNullException

value ist null.

ArgumentOutOfRangeException

startIndex oder length ist kleiner als 0.

- oder -

Die durch value + startIndex angegebene Adresse ist für die aktuelle Plattform zu groß, d.h., bei der Berechnung der Adresse ist ein Überlauf aufgetreten.

- oder -

Die Länge der zu initialisierenden neuen Zeichenfolge ist zu groß und kann daher nicht zugeordnet werden.

ArgumentException

Die durch value + startIndex angegebene Adresse ist kleiner als 64K.

- oder -

Eine neue Instanz von String konnte nicht mit value initialisiert werden, wobei angenommen wurde, dass value in ANSI codiert ist.

AccessViolationException

value, startIndex und length geben zusammen eine ungültige Adresse an.

Hinweise

Hinweis

Beispiele und umfassende Informationen zur Verwendung dieser und anderer String Konstruktorüberladungen finden Sie in der String Konstruktorzusammenfassung.

Gilt für:

String(SByte*, Int32, Int32, Encoding)

Wichtig

Diese API ist nicht CLS-kompatibel.

public:
 String(System::SByte* value, int startIndex, int length, System::Text::Encoding ^ enc);

[System.CLSCompliant(false)]
public String (sbyte* value, int startIndex, int length, System.Text.Encoding enc);

public String (sbyte* value, int startIndex, int length, System.Text.Encoding enc);

[System.CLSCompliant(false)]
[System.Security.SecurityCritical]
public String (sbyte* value, int startIndex, int length, System.Text.Encoding enc);

[<System.CLSCompliant(false)>]
new string : nativeptr<sbyte> * int * int * System.Text.Encoding -> string

new string : nativeptr<sbyte> * int * int * System.Text.Encoding -> string

[<System.CLSCompliant(false)>]
[<System.Security.SecurityCritical>]
new string : nativeptr<sbyte> * int * int * System.Text.Encoding -> string

Parameter

value: SByte*

Ein Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen.

startIndex: Int32

Die Anfangsposition in value.

length: Int32

Die Anzahl der aus value zu verwendenden Zeichen.

enc: Encoding

Ein Objekt, das angibt, wie das Array codiert ist, auf das value verweist. Wenn encnull ist, wird von ANSI-Codierung ausgegangen.

Attribute: CLSCompliantAttribute SecurityCriticalAttribute

Ausnahmen

ArgumentNullException

value ist null.

ArgumentOutOfRangeException

startIndex oder length ist kleiner als 0.

- oder -

Die durch value + startIndex angegebene Adresse ist für die aktuelle Plattform zu groß, d.h., bei der Berechnung der Adresse ist ein Überlauf aufgetreten.

- oder -

Die Länge der zu initialisierenden neuen Zeichenfolge ist zu groß und kann daher nicht zugeordnet werden.

ArgumentException

Die durch value + startIndex angegebene Adresse ist kleiner als 64K.

- oder -

Eine neue Instanz von String konnte nicht mit value initialisiert werden, wobei angenommen wurde, dass value entsprechend der Angabe durch enc codiert ist.

AccessViolationException

value, startIndex und length geben zusammen eine ungültige Adresse an.

Hinweise

Hinweis

Beispiele und umfassende Informationen zur Verwendung dieser und anderer String Konstruktorüberladungen finden Sie in der String Konstruktorzusammenfassung.

Gilt für: