String Konstruktoren

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.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 des überladenen Konstruktors
Parameter
Ausnahmen
Welche Methode rufe ich auf?
Erstellen von Zeichenfolgen
Behandeln von sich wiederholenden Zeichenfolgen

Beispiele für die Instanziierung 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 des überladenen Konstruktors

Zeichenfolgenkonstruktoren fallen in zwei Kategorien: diejenigen ohne Zeigerparameter und diejenigen mit Zeigerparametern. Die Konstruktoren, die Zeiger verwenden, sind nicht CLS-konform. 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 instance 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 instance mit dem Wert, der durch ein Array von Unicode-Zeichen, eine Startzeichenposition innerhalb dieses Arrays und eine Länge (Beispiel) angegeben wird.

String(Char c, Int32 count)
Initialisiert die neue instance mit dem Wert, der durch ein angegebenes Unicode-Zeichen angegeben wird, das mehrmals wiederholt wird (Beispiel).

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

Berechtigung: SecurityCriticalAttribute, erfordert vollständige Vertrauenswürdigstellung für den unmittelbaren Aufrufer. Dieser Member kann nicht von teilweise vertrauenswürdigem oder transparentem Code verwendet werden.

String(char* value, Int32 startIndex, Int32 length)
(Nicht CLS-konform) Initialisiert die neue instance mit dem Wert, der durch einen Zeiger auf ein Array von Unicode-Zeichen, eine Startzeichenposition innerhalb dieses Arrays und eine Länge angegeben wird. Der Konstruktor kopiert die Unicode-Zeichen von value anfang bei index startIndex und enden bei indexlengthstartIndex + - 1 (Beispiel).

String(SByte* value)
(Nicht CLS-konform) Initialisiert die neue instance 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 Zeichenfolge darstellt, die mit der aktuellen Systemcodepage codiert ist (d. a. die durch Encoding.Defaultangegebene Codierung). Der Konstruktor verarbeitet Zeichen von value der vom Zeiger angegebenen Position bis zum Erreichen eines NULL-Zeichens (0x00) (Beispiel).

String(SByte* value, Int32 startIndex, Int32 length)
(Nicht CLS-konform) Initialisiert die neue instance mit dem Wert, der durch einen Zeiger auf ein Array mit 8-Bit-Ganzzahlen mit Vorzeichen, einer Startposition innerhalb dieses Arrays und einer Länge angegeben wird. Es wird davon ausgegangen, dass das Array eine Zeichenfolge darstellt, die mit der aktuellen Systemcodepage codiert ist (d. a. die durch Encoding.Defaultangegebene Codierung). Der Konstruktor verarbeitet Zeichen vom Wert, der bei startIndex - 1 beginnt und endetlengthstartIndex + (Beispiel).

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

Parameter

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

Parameter	type	BESCHREIBUNG
`value`	Char[]	Ein Array von Unicode-Zeichen.
`c`	Char	Ein Unicode-Zeichen.
`startIndex`	Int32	Die Startposition in `value` des ersten Zeichens in der neuen Zeichenfolge. Standardwert: 0
`length`	Int32	Die Anzahl der Zeichen, die in `value` die neue Zeichenfolge eingeschlossen werden sollen. Standardwert: Array.Length
`count`	Int32	Die Anzahl der Wiederholungen des Zeichens `c` in der neuen Zeichenfolge. Wenn `count` null ist, ist String.Emptyder Wert des neuen Objekts .

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

Parameter	type	BESCHREIBUNG
`value`	Char* - oder - SByte*	Ein Zeiger auf ein Null-endendes Array von Unicode-Zeichen oder ein Array von 8-Bit-Ganzzahlen mit Vorzeichen. Wenn `value` es sich um ein leeres Array handelt `null` , ist String.Emptyder Wert der neuen Zeichenfolge .
`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 sollen. Wenn die Länge 0 ist, erstellt der Konstruktor eine Zeichenfolge, deren Wert ist String.Empty. Standardwert: Array.Length
`enc`	Encoding	Ein -Objekt, das angibt, wie das `value` Array codiert wird. Standardwert: Encoding.Defaultoder die aktuelle ANSI-Codepage des Systems

Ausnahmen

Hier sehen 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 `count` ist kleiner als 00. - 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)

Hier sehen 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 64 KB ist. - oder - Eine neue String instance konnte nicht aus dem `value` Bytearray initialisiert werden, da `value` die Standardcodepagecodierung nicht verwendet wird.	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ß, um sie zuzuordnen.	Alle Konstruktoren mit Zeigern.
AccessViolationException	`value`oder `value` + + `startIndexlength` - 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, indem Sie dessen Zeiger verwenden.	String(Char*, Int32, Int32)
Erstellen Sie eine Zeichenfolge aus einem C++- `char` 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

Die am häufigsten verwendete Technik zum programmgesteuerten Erstellen von Zeichenfolgen ist eine 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 String Objekt aus den Zeichen im gesamten Array oder 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 vom Index startIndex in den Index startIndex + length 1 in die neue Zeichenfolge. Wenn length null ist, ist String.Emptyder Wert der neuen Zeichenfolge .

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 mit dem String(Char, Int32) Konstruktor einmal oder mehrmals dupliziert wird. Wenn count null ist, ist String.Emptyder Wert der neuen Zeichenfolge .
Von einem Zeiger auf ein Zeichenarray mit NULL-Beendigung mithilfe des String(Char*) -Konstruktors oder String(Char*, Int32, Int32) . Entweder das gesamte Array oder ein angegebener Bereich kann verwendet werden, um die Zeichenfolge zu initialisieren. Der Konstruktor kopiert eine Sequenz von Unicode-Zeichen, beginnend mit dem angegebenen Zeiger oder vom angegebenen Zeiger plus startIndex und wird bis zum Ende des Arrays oder für length Zeichen fortgesetzt. Wenn value ein NULL-Zeiger oder length null ist, erstellt der Konstruktor eine Zeichenfolge, deren Wert ist String.Empty. Wenn der Kopiervorgang am Ende des Arrays fortgesetzt wird und das Array nicht null-beendet ist, ist das Konstruktorverhalten systemabhängig. Eine solche Bedingung kann zu einer Zugriffsverletzung führen.

Wenn das Array eingebettete NULL-Zeichen (U+0000 oder "\0") enthält und die String(Char*, Int32, Int32) Überladung aufgerufen wird, enthält length die Zeichenfolge instance Zeichen, einschließlich eingebetteter NULL-Werte. Das folgende Beispiel zeigt, was passiert, wenn ein Zeiger auf ein Array von 10 Elementen, das zwei NULL-Zeichen enthält, an die String(Char*, Int32, Int32) -Methode übergeben 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 eingebetteten NULL-Werten. Wenn hingegen das gleiche Array an den String(Char*) Konstruktor übergeben wird, ist das Ergebnis eine vierstellige Zeichenfolge, die das erste 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
```
```
#nowarn "9"
open System

let chars = [| 'a'; 'b'; 'c'; 'd'; '\000'; 'A'; 'B'; 'C'; 'D'; '\000' |]
let s =
    use chPtr = fixed chars
    String(chPtr, 0, chars.Length)

for ch in s do
    printf $"{uint16 ch:X4} "
printfn ""

let s2 = 
    use chPtr = fixed chars
    String chPtr    

for ch in s2 do
    printf $"{uint16 ch:X4} "
printfn ""  
// The example displays the following output:
//       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
//       0061 0062 0063 0064
```
Das Array muss Unicode-Zeichen enthalten. In C++ bedeutet dies, dass das Zeichenarray entweder als verwalteter Char[]-Typ oder als nicht verwalteterwchar_t[]-Typ definiert werden muss.

Wenn die String(Char*) Überladung aufgerufen wird und das Array nicht null-beendet ist, oder wenn die String(Char*, Int32, Int32) Überladung aufgerufen wird und startIndex + length-1 einen Bereich enthält, der außerhalb des für die Zeichensequenz zugeordneten Arbeitsspeichers liegt, ist das Verhalten des Konstruktors systemabhängig, und es kann zu einer Zugriffsverletzung kommen.

Von einem Zeiger auf ein bytesigniertes Array. Entweder das gesamte Array oder ein angegebener Bereich kann verwendet werden, um die Zeichenfolge zu initialisieren. Die Bytesequenz kann mithilfe der standardmäßigen Codepagecodierung interpretiert werden, oder im Konstruktoraufruf kann eine Codierung angegeben werden. Wenn der Konstruktor versucht, eine Zeichenfolge aus einem gesamten Array zu instanziieren, das nicht mit NULL beendet ist, oder wenn der Bereich des Arrays von value + startIndex bis - + value + startIndexlength1 außerhalb des für das Array zugeordneten Arbeitsspeichers liegt, ist das Verhalten dieses Konstruktors systemabhängig, und es kann zu einer Zugriffsverletzung kommen.

Die drei Konstruktoren, die ein Bytearray mit Vorzeichen als Parameter enthalten, dienen in erster Linie zum Konvertieren eines C++- char Arrays in eine Zeichenfolge, wie in diesem 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 String(SByte*, Int32, Int32) Überladung aufgerufen wird, enthält length die Zeichenfolge instance Zeichen, einschließlich eingebetteter NULL-Werte. Das folgende Beispiel zeigt, was passiert, wenn ein Zeiger auf ein Array von 10 Elementen, das zwei NULL-Zeichen enthält, an die String(SByte*, Int32, Int32) -Methode übergeben 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 eingebetteten NULL-Werten. Wenn hingegen das gleiche Array an den String(SByte*) Konstruktor übergeben wird, ist das Ergebnis eine vierstellige Zeichenfolge, die das erste 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

#nowarn "9"
open System

let bytes = 
    [| 0x61y; 0x62y; 0x063y; 0x064y; 0x00y; 0x41y; 0x42y; 0x43y; 0x44y; 0x00y |]

let s =
    use bytePtr = fixed bytes
    String(bytePtr, 0, bytes.Length)

for ch in s do
    printf $"{uint16 ch:X4} "
printfn ""

let s2 =
    use bytePtr = fixed bytes
    String bytePtr         

for ch in s do
    printf $"{uint16 ch:X4} "
printfn ""
// The example displays the following output:
//       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
//       0061 0062 0063 0064

Da die String(SByte*) Konstruktoren und String(SByte*, Int32, Int32) mithilfe der ANSI-Standardcodepage interpretiert value werden, können beim Aufrufen dieser Konstruktoren mit identischen Bytearrays Zeichenfolgen mit unterschiedlichen Werten auf verschiedenen Systemen erstellt werden.

Behandeln von sich wiederholenden Zeichenfolgen

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

Angenommen, Sie lesen und analysieren einen Datenstrom von Zeichen aus einer Datei, die XML-Tags und -Attribute enthält. Wenn Sie den Datenstrom analysieren, treffen Sie wiederholt auf bestimmte Token (d. h. Sequenzen von Zeichen, die eine symbolische Bedeutung haben). 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 System.Xml.NameTable -Objekt erstellen, das häufig vorkommende Zeichenfolgen enthält. Das NameTable -Objekt verbessert die Leistung, da es gespeicherte Zeichenfolgen abruft, ohne temporären Arbeitsspeicher zuzuweisen. 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 NameTable.Add(Char[], Int32, Int32) -Methode, um das Token in die Tabelle einzufügen und die entsprechende Zeichenfolge abzurufen.

Beispiel 1: Verwenden der Zeichenfolgenzuweisung

Im folgenden Beispiel wird eine neue Zeichenfolge erstellt, indem ein Zeichenfolgenliteral zugewiesen wird. Es erstellt eine zweite Zeichenfolge, indem ihr der Wert der ersten Zeichenfolge zugewiesen wird. Dies sind die beiden häufigsten 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.

let value1 = "This is a string."
let value2 = value1
printfn "%s" value1
printfn "%s" value2
// The example displays the following output:
//    This is a string.
//    This is a string.

Module Example
   Public Sub Main()
      Dim value1 As String = "This is a string."
      Dim value2 As String = value1
      Console.WriteLine(value1)
      Console.WriteLine(value2)
   End Sub
End Module
' The example displays the following output:
'    This is a string.
'    This is a string.

Beispiel 2: Verwenden eines Zeichenarrays

Im folgenden Beispiel wird veranschaulicht, wie ein neues String -Objekt 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
let charArr1 = [| '\u2200'; '\u2202'; '\u200F'; '\u2205' |]
let szMathSymbols = String charArr1

// Unicode Letterlike Symbols
let charArr2 = [| '\u2111'; '\u2118'; '\u2122'; '\u2126' |]
let szLetterLike = String charArr2

// Compare Strings - the result is false
printfn $"The Strings are equal? %b{String.Compare(szMathSymbols, szLetterLike) = 0}"

' Unicode Mathematical operators
Dim charArr1() As Char = {ChrW(&H2200), ChrW(&H2202), _
                          ChrW(&H200F), ChrW(&H2205)}
Dim szMathSymbols As New String(charArr1)

' Unicode Letterlike Symbols
Dim charArr2() As Char = {ChrW(&H2111), ChrW(&H2118), _
                          ChrW(&H2122), ChrW(&H2126)}
Dim szLetterLike As New String(charArr2)

' Compare Strings - the result is false
Console.WriteLine("The strings are equal? " & _
        CStr(szMathSymbols.Equals(szLetterLike)))

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

Im folgenden Beispiel wird veranschaulicht, wie ein neues String Objekt aus einem Teil eines Zeichenarrays erstellt wird und wie ein neues String Objekt erstellt wird, das mehrere Vorkommen eines 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
let szGreekAlpha = String('\u0391',5)
// Create a Unicode String with a Greek Omega character
let szGreekOmega = String([| '\u03A9'; '\u03A9'; '\u03A9' |],2,1)

let szGreekLetters = String.Concat(szGreekOmega, szGreekAlpha, szGreekOmega.Clone())

// Examine the result
printfn $"{szGreekLetters}"

// The first index of Alpha
let ialpha = szGreekLetters.IndexOf '\u0391'
// The last index of Omega
let iomega = szGreekLetters.LastIndexOf '\u03A9'

printfn $"The Greek letter Alpha first appears at index {ialpha} and Omega last appears at index {iomega} in this String."

' Create a Unicode String with 5 Greek Alpha characters
Dim szGreekAlpha As New String(ChrW(&H0391), 5)
' Create a Unicode String with a Greek Omega character
Dim szGreekOmega As New String(New Char() {ChrW(&H03A9), ChrW(&H03A9), _
                                           ChrW(&H03A9)}, 2, 1)

Dim szGreekLetters As String = String.Concat(szGreekOmega, szGreekAlpha, _
                                             szGreekOmega.Clone())

' Examine the result
Console.WriteLine(szGreekLetters)

' The first index of Alpha
Dim iAlpha As Integer = szGreekLetters.IndexOf(ChrW(&H0391))
' The last index of Omega
Dim iomega As Integer = szGreekLetters.LastIndexOf(ChrW(&H03A9))

Console.WriteLine("The Greek letter Alpha first appears at index {0}.", _ 
                  ialpha)
Console.WriteLIne("The Greek letter Omega last appears at index {0}.", _
                  iomega)

Beispiel 4: Verwenden eines Zeigers auf ein Zeichenarray

Im folgenden Beispiel wird veranschaulicht, wie ein neues String Objekt aus einem Zeiger auf ein Array von Zeichen erstellt wird. Das C#-Beispiel muss mithilfe des /unsafe Compilerswitches 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!

#nowarn "9"
open System

let characters = 
    [| 'H'; 'e'; 'l'; 'l'; 'o'; ' ' 
       'w'; 'o'; 'r'; 'l'; 'd'; '!'; '\u0000' |]

let value =
    use charPtr = fixed characters
    String charPtr

printfn $"{value}"
// The example displays the following output:
//        Hello world!

Beispiel 5: Instanziieren einer Zeichenfolge aus einem Zeiger und einem Bereich eines Arrays

Im folgenden Beispiel werden die Elemente eines Zeichenarrays für einen Punkt oder ein Ausrufezeichen untersucht. Wenn eine gefunden wird, instanziiert sie eine Zeichenfolge aus den Zeichen im Array, die dem Interpunktionssymbol vorangestellt sind. Andernfalls instanziiert sie eine Zeichenfolge mit dem gesamten Inhalt des Arrays. Das C#-Beispiel muss mithilfe des /unsafe Compilerswitches 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

#nowarn "9"
open System
open FSharp.NativeInterop

let characters = 
    [| 'H'; 'e'; 'l'; 'l'; 'o'; ' '
       'w'; 'o'; 'r'; 'l'; 'd'; '!'; '\u0000' |]

[<EntryPoint>]
let main _ =
    use charPtr = fixed characters
    let mutable length = 0
    let mutable iterator = charPtr
    let mutable broken = false
    while not broken && NativePtr.read iterator <> '\u0000' do
        if NativePtr.read iterator = '!' || NativePtr.read iterator = '.' then
            broken <- true
        else
            iterator <- NativePtr.add iterator 1
            length <- length + 1
    String(charPtr, 0, length)
    |> printfn "%s"
    0
// The example displays the following output:
//      Hello World

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

Im folgenden Beispiel wird veranschaulicht, wie Sie mit dem String(SByte*) Konstruktor eine instance der String -Klasse erstellen 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") );
}

// Null terminated ASCII characters in an sbyte array
let szAsciiUpper =
    let sbArr1 = [| 0x41y; 0x42y; 0x43y; 0x00y |]
    // Instruct the Garbage Collector not to move the memory
    use pAsciiUpper = fixed sbArr1
    String pAsciiUpper

let szAsciiLower =
    let sbArr2 = [| 0x61y; 0x62y; 0x63y; 0x00y |]
    // Instruct the Garbage Collector not to move the memory
    use pAsciiLower = fixed sbArr2 
    String(pAsciiLower, 0, sbArr2.Length)

// Prints "ABC abc"
printfn $"{szAsciiUpper} {szAsciiLower}"

// Compare Strings - the result is true
printfn $"The Strings are equal when capitalized ? %b{String.Compare(szAsciiUpper.ToUpper(), szAsciiLower.ToUpper()) = 0}"

// This is the effective equivalent of another Compare method, which ignores case
printfn $"The Strings are equal when capitalized ? %b{String.Compare(szAsciiUpper, szAsciiLower, true) = 0}"

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 Informationen zur Verwendung dieser und anderer String Konstruktorüberladungen 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);

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

[<System.CLSCompliant(false)>]
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);

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

[<System.CLSCompliant(false)>]
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);

[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

[<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 Zusammenfassung des String Konstruktors.

Gilt für:

String Konstruktoren

Definition

Überlädt

Hinweise

Syntax des überladenen Konstruktors

Parameter

Ausnahmen

Welche Methode rufe ich auf?

Erstellen von Zeichenfolgen

Behandeln von sich wiederholenden Zeichenfolgen

Beispiel 1: Verwenden der Zeichenfolgenzuweisung

Beispiel 2: Verwenden eines Zeichenarrays

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

Beispiel 4: Verwenden eines Zeigers auf ein Zeichenarray

Beispiel 5: Instanziieren einer Zeichenfolge aus einem Zeiger und einem Bereich eines Arrays

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

String(Char*)

Parameter

Ausnahmen

Hinweise

Gilt für:

String(Char[])

Parameter

Hinweise

Gilt für:

String(ReadOnlySpan<Char>)

Parameter

Gilt für:

String(SByte*)

Parameter

Ausnahmen

Hinweise

Gilt für:

String(Char, Int32)

Parameter

Ausnahmen

Hinweise

Gilt für:

String(Char*, Int32, Int32)

Parameter

Ausnahmen

Hinweise

Gilt für:

String(Char[], Int32, Int32)

Parameter

Ausnahmen

Hinweise

Gilt für:

String(SByte*, Int32, Int32)

Parameter

Ausnahmen

Hinweise

Gilt für:

String(SByte*, Int32, Int32, Encoding)

Parameter

Ausnahmen

Hinweise

Gilt für:

Zusätzliche Ressourcen