String String String String Constructors

Definition

Überlädt

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

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

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

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

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

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

String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>)
String(Char[]) String(Char[]) String(Char[]) String(Char[])

Initialisiert eine neue Instanz der String-Klasse mit dem durch ein Array von Unicode-Zeichen angegebenen Wert.Initializes a new instance of the String class to the value indicated by an array of Unicode characters.

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

Hinweise

In diesem AbschnittIn this section:

Der überladene Konstruktor-syntax Overloaded constructor syntax
Parameter Parameters
Ausnahmen Exceptions
Welche Methode rufe ich? Which method do I call?
Erstellen von Zeichenfolgen Creating strings
Behandlung von Zeichenfolgen Handling repetitive strings
Beispiele für Zeichenfolgen mit instanziieren:Examples of instantiating strings:
Mit der Zeichenfolge-ZuweisungUsing string assignment
Verwenden ein Array von ZeichenUsing a character array
Verwenden einen Teil eines Arrays von Zeichen, und wiederholen ein einzelnes ZeichenUsing a portion of a character array and repeating a single character
Mithilfe eines Zeigers auf ein Array von ZeichenUsing a pointer to a character array
Verwenden einen Zeiger und einen Bereich eines ArraysUsing a pointer and a range of an array
Mithilfe eines Zeigers auf ein Bytearray mit VorzeichenUsing a pointer to a signed byte array
VersionsinformationenVersion information

Der überladene Konstruktor-syntaxOverloaded constructor syntax

Konstruktoren für Zeichenfolge in zwei Kategorien unterteilen: ohne Zeigerparameter an, und die mit Zeigerparameter.String constructors fall into two categories: those without pointer parameters, and those with pointer parameters. Die Konstruktoren, die Zeiger verwenden, sind nicht CLS-kompatibel.The constructors that use pointers are not CLS-compliant. Darüber hinaus Visual Basic unterstützt nicht die Verwendung von Zeigern und in c# muss Code, der Zeiger verwendet wird, um in einem unsicheren Kontext auszuführen.In addition, Visual Basic does not support the use of pointers, and C# requires code that uses pointers to run in an unsafe context. Weitere Informationen finden Sie unter unsafe.For more information, see unsafe.

Weitere Anleitungen zum Auswählen einer Überladung finden Sie unter welche Methode rufe ich?For additional guidance on choosing an overload, see Which method do I call?

String(Char[] value)
Initialisiert die neue Instanz mit dem Wert durch ein Array von Unicode-Zeichen.Initializes the new instance to the value indicated by an array of Unicode characters. Dieser Konstruktor kopiert die Unicode-Zeichen (Beispiel).This constructor copies Unicode characters(example).

String(Char[] value, Int32 startIndex, Int32 length)
Initialisiert die neue Instanz mit dem Wert durch ein Array von Unicode-Zeichen, die Position des ersten Zeichens innerhalb dieses Arrays, und die Länge (Beispiel).Initializes the new instance to the value indicated by an array of Unicode characters, a starting character position within that array, and a length (example).

String(Char c, Int32 count)
Eine angegebene Anzahl von Malen wiederholt, initialisiert die neue Instanz mit dem Wert angegeben wird, durch ein angegebenes Unicodezeichen (Beispiel).Initializes the new instance to the value indicated by a specified Unicode character repeated a specified number of times (example).

String(char* value)
(Nicht CLS-kompatibel) Initialisiert die neue Instanz mit dem Wert durch einen Zeiger auf ein Array von Unicode-Zeichen, die durch ein Null-Zeichen beendet wird (U + 0000 oder '\0').(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of Unicode characters that is terminated by a null character (U+0000 or '\0'). (Beispiel).(example).

Berechtigung: SecurityCriticalAttribute, erfordert volle Vertrauenswürdigkeit für den unmittelbaren Aufrufer.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Dieser Member kann nicht von teilweise vertrauenswürdigem oder transparentem Code verwendet werden.This member cannot be used by partially trusted or transparent code.

String(char* value, Int32 startIndex, Int32 length)
(Nicht CLS-kompatibel) Initialisiert die neue Instanz mit dem Wert durch einen Zeiger auf ein Array von Unicode-Zeichen, die Position des ersten Zeichens innerhalb dieses Arrays und eine Länge angegeben.(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of Unicode characters, a starting character position within that array, and a length. Der Konstruktor kopiert die Unicode-Zeichen von value beginnend am Index startIndex und endet am Index startIndex + length - 1 (Beispiel).The constructor copies the Unicode characters from value starting at index startIndex and ending at index startIndex + length - 1 (example).

Berechtigung: SecurityCriticalAttribute, erfordert volle Vertrauenswürdigkeit für den unmittelbaren Aufrufer.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Dieser Member kann nicht von teilweise vertrauenswürdigem oder transparentem Code verwendet werden.This member cannot be used by partially trusted or transparent code.

String(SByte* value)
(Nicht CLS-kompatibel) Initialisiert die neue Instanz mit dem Wert durch einen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen.(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of 8-bit signed integers. Das Array wird davon ausgegangen, dass zur Darstellung einer Zeichenfolge, die mit der aktuellen Codepage des Systems codiert (d. h. durch angegebene Codierung Encoding.Default).The array is assumed to represent a string encoded using the current system code page (that is, the encoding specified by Encoding.Default). Der Konstruktor verarbeitet die Zeichen aus value beginnend an der vom Zeiger angegeben werden, bis ein Null-Zeichen (0 x 00) erreicht ist (Beispiel).The constructor processes characters from value starting from the location specified by the pointer until a null character (0x00) is reached (example).

Berechtigung: SecurityCriticalAttribute, erfordert volle Vertrauenswürdigkeit für den unmittelbaren Aufrufer.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Dieser Member kann nicht von teilweise vertrauenswürdigem oder transparentem Code verwendet werden.This member cannot be used by partially trusted or transparent code.

String(SByte* value, Int32 startIndex, Int32 length)
(Nicht CLS-kompatibel) Initialisiert die neue Instanz auf den Wert durch einen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen, die Startposition innerhalb dieses Arrays und eine Länge angegeben.(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of 8-bit signed integers, a starting position within that array, and a length. Das Array wird davon ausgegangen, dass zur Darstellung einer Zeichenfolge, die mit der aktuellen Codepage des Systems codiert (d. h. durch angegebene Codierung Encoding.Default).The array is assumed to represent a string encoded using the current system code page (that is, the encoding specified by Encoding.Default). Der Konstruktor verarbeitet Zeichen aus beginnend mit Wert startIndex und endet um startIndex + length - 1 (Beispiel).The constructor processes characters from value starting at startIndex and ending at startIndex + length - 1 (example).

Berechtigung: SecurityCriticalAttribute, erfordert volle Vertrauenswürdigkeit für den unmittelbaren Aufrufer.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Dieser Member kann nicht von teilweise vertrauenswürdigem oder transparentem Code verwendet werden.This member cannot be used by partially trusted or transparent code.

String(SByte* value, Int32 startIndex, Int32 length, Encoding enc)
(Nicht CLS-kompatibel) Initialisiert die neue Instanz mit dem Wert durch einen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen, Startposition innerhalb dieses Arrays, eine Länge und ein Encoding Objekt.(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of 8-bit signed integers, a starting position within that array, a length, and an Encoding object.

Berechtigung: SecurityCriticalAttribute, erfordert volle Vertrauenswürdigkeit für den unmittelbaren Aufrufer.Permission: SecurityCriticalAttribute, requires full trust for the immediate caller. Dieser Member kann nicht von teilweise vertrauenswürdigem oder transparentem Code verwendet werden.This member cannot be used by partially trusted or transparent code.

ParameterParameters

Hier ist eine vollständige Liste der von verwendeten Parameter String Konstruktoren, die einen Zeigerparameter nicht enthalten.Here is a complete list of parameters used by String constructors that don't include a pointer parameter. Die Parameter, die von jeder Überladung verwendet wird finden Sie unter die oben stehende Syntax Überladung.For the parameters used by each overload, see the overload syntax above.

ParameterParameter TypType BeschreibungDescription
value Char[]Char[] Ein Array von Unicode-Zeichen.An array of Unicode characters.
c Char Ein Unicode-Zeichen.A Unicode character.
startIndex Int32 Die Anfangsposition in value des ersten Zeichens in der neuen Zeichenfolge.The starting position in value of the first character in the new string.

Standardwert: 0Default value: 0
length Int32 Die Anzahl der Zeichen in value in der neuen Zeichenfolge eingeschlossen werden sollen.The number of characters in value to include in the new string.

Standardwert: Array.LengthDefault value: Array.Length
count Int32 Die Häufigkeit, mit des Zeichens c wird in der neuen Zeichenfolge wiederholt.The number of times the character c is repeated in the new string. Wenn count NULL ist, wird der Wert des neuen Objekts String.Empty.If count is zero, the value of the new object is String.Empty.

Hier ist eine vollständige Liste der von verwendeten Parameter String Konstruktoren, die einen Zeigerparameter enthalten.Here is a complete list of parameters used by String constructors that include a pointer parameter. Die Parameter, die von jeder Überladung verwendet wird finden Sie unter die oben stehende Syntax Überladung.For the parameters used by each overload, see the overload syntax above.

ParameterParameter TypType BeschreibungDescription
value Char*

- oder --or-

SByte*
Ein Zeiger auf eine mit Null endendes Array von Unicode-Zeichen oder ein Array von 8-Bit-Ganzzahlen mit Vorzeichen.A pointer to a null-terminated array of Unicode characters or an array of 8-bit signed integers. Wenn value ist null oder ein leeres Array ist der Wert der neuen Zeichenfolge String.Empty.If value is null or an empty array, the value of the new string is String.Empty.
startIndex Int32 Der Index des Arrayelements dar, der das erste Zeichen in der neuen Zeichenfolge definiert.The index of the array element that defines the first character in the new string.

Standardwert: 0Default value: 0
length Int32 Die Anzahl der Elemente des Arrays zu verwenden, um die neue Zeichenfolge zu erstellen.The number of array elements to use to create the new string. Wenn die Länge 0 (null) ist, wird der Konstruktor erstellt eine Zeichenfolge, deren Wert String.Empty.If length is zero, the constructor creates a string whose value is String.Empty.

Standardwert: Array.LengthDefault value: Array.Length
enc Encoding Ein Objekt, der angibt, wie die value Array codiert ist.An object that specifies how the value array is encoded.

Standardwert: Encoding.Default, oder der aktuellen ANSI-Codepage des SystemsDefault value: Encoding.Default, or the system's current ANSI code page

AusnahmenExceptions

Hier ist eine Liste der Ausnahmen, die von den Konstruktoren, die keine Zeigerparameter enthalten.Here's a list of exceptions thrown by constructors that don't include pointer parameters.

AusnahmeException BedingungCondition Ausgelöst durchThrown by
ArgumentNullException value ist null.value is null. String(Char[], Int32, Int32)
ArgumentOutOfRangeException startIndex,length, oder count ist kleiner als 0 (null).startIndex,length, or count is less than zero.

- oder --or-

Die Summe von startIndex und length ist größer als die Anzahl von Elementen in value.The sum of startIndex and length is greater than the number of elements in value.

- oder --or-

count ist kleiner als Null.count is less than zero.
String(Char, Int32)

String(Char[], Int32, Int32)

Hier ist eine Liste der Ausnahmen, die von den Konstruktoren, die Zeigerparameter enthalten.Here's a list of exceptions thrown by constructors that include pointer parameters.

AusnahmeException BedingungCondition Ausgelöst durchThrown by
ArgumentException value Gibt ein Array, das ein ungültiges Unicodezeichen enthält.value specifies an array that contains an invalid Unicode character.

- oder --or-

value oder value + startIndex gibt an, eine Adresse kleiner als 64K.value or value + startIndex specifies an address that is less than 64K.

- oder --or-

Ein neues String Instanz konnte nicht initialisiert werden, aus der value Bytearray da value verwendet nicht die standardmäßige Systemcodeseiten-Codierung.A new String instance could not be initialized from the value byte array because value does not use the default code page encoding.
Alle Konstruktoren mit Zeigern.All constructors with pointers.
ArgumentNullException value ist NULL.value is null. String(SByte*)

String(SByte*, Int32, Int32)

String(SByte*, Int32, Int32, Encoding)
ArgumentOutOfRangeException Der aktuelle Prozess hat keinen Lesezugriff auf alle adressierten Zeichen.The current process does not have read access to all the addressed characters.

- oder --or-

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

- oder --or-

Die Länge der neuen Zeichenfolge ist zu groß für die Zuordnung.The length of the new string is too large to allocate.
Alle Konstruktoren mit Zeigern.All constructors with pointers.
AccessViolationException value, oder value + startIndex + length -1, gibt eine ungültige Adresse.value, or value + startIndex + length - 1, specifies an invalid address. String(SByte*)

String(SByte*, Int32, Int32)

String(SByte*, Int32, Int32, Encoding)

Welche Methode rufe ich?Which method do I call?

BeschreibungTo Aufruf, oder verwendenCall or use
Eine Zeichenfolge zu erstellen.Create a string. Zuweisung von einem Zeichenfolgenliteral oder eine vorhandene Zeichenfolge (Beispiel)Assignment from a string literal or an existing string (example)
Erstellen Sie eine Zeichenfolge aus einem Array ganze Zeichen ein.Create a string from an entire character array. String(Char[]) (Beispiel)String(Char[]) (example)
Erstellen Sie eine Zeichenfolge aus einem Abschnitt eines Arrays von Zeichen an.Create a string from a portion of a character array. String(Char[], Int32, Int32) (Beispiel)String(Char[], Int32, Int32) (example)
Erstellen Sie eine Zeichenfolge, die das gleiche Zeichen mehrere Male wiederholt.Create a string that repeats the same character multiple times. String(Char, Int32) (Beispiel)String(Char, Int32) (example)
Erstellen Sie eine Zeichenfolge von einem Zeiger auf eine Unicode- oder ein Array mit Breitzeichen.Create a string from a pointer to a Unicode or wide character array. String(Char*)
Erstellen Sie eine Zeichenfolge mithilfe der Zeiger aus einem Abschnitt eine Unicode-oder ein Array mit Breitzeichen.Create a string from a portion of a Unicode or wide character array by using its pointer. String(Char*, Int32, Int32)
Erstellen Sie eine Zeichenfolge aus einer C++ char Array.Create a string from a C++ char array. String(SByte*), String(SByte*, Int32, Int32)String(SByte*), String(SByte*, Int32, Int32)

- oder --or-

String(SByte*, Int32, Int32, Encoding)
Erstellen Sie eine Zeichenfolge, aus ASCII-Zeichen.Create a string from ASCII characters. ASCIIEncoding.GetString

Erstellen von ZeichenfolgenCreating strings

Die am häufigsten verwendeten Verfahren für programmgesteuerte Erstellung von Zeichenfolgen einfache Zuweisung, siehe in diesem Beispiel.The most commonly used technique for creating strings programmatically is simple assignment, as illustrated in this example. Die String -Klasse enthält auch vier Typen von überladene Konstruktoren verfügbar, mit denen Sie die Zeichenfolgen aus den folgenden Werten zu erstellen:The String class also includes four types of constructor overloads that let you create strings from the following values:

  • Aus einem Array mit Zeichen (ein Array von UTF-16-codierte Zeichen).From a character array (an array of UTF-16-encoded characters). Sie können ein neues erstellen String Objekt aus der Zeichen in das gesamte Array oder einen Teil davon.You can create a new String object from the characters in the entire array or a portion of it. Die String(Char[]) Konstruktor kopiert alle Zeichen im Array, in die neue Zeichenfolge.The String(Char[]) constructor copies all the characters in the array to the new string. Die String(Char[], Int32, Int32) Konstruktor kopiert die Zeichen aus dem Index startIndex Index startIndex + length -1, um die neue Zeichenfolge.The String(Char[], Int32, Int32) constructor copies the characters from index startIndex to index startIndex + length - 1 to the new string. Wenn length NULL ist, wird der Wert der neuen Zeichenfolge String.Empty.If length is zero, the value of the new string is String.Empty.

    Wenn Ihr Code wiederholt Zeichenfolgen, die den gleichen Wert verfügen instanziiert, können Sie die Anwendungsleistung verbessern, mit der eine alternative Möglichkeit für das Erstellen von Zeichenfolgen.If your code repeatedly instantiates strings that have the same value, you can improve application performance by using an alternate means of creating strings. Weitere Informationen finden Sie unter Behandlung von Zeichenfolgen.For more information, see Handling repetitive strings.

  • Von einem einzelnen Zeichen, das doppelte 0 (null), einen oder mehrere Male, mit der String(Char, Int32) Konstruktor.From a single character that is duplicated zero, one, or more times, by using the String(Char, Int32) constructor. Wenn count NULL ist, wird der Wert der neuen Zeichenfolge String.Empty.If count is zero, the value of the new string is String.Empty.

  • Mithilfe von einem Zeiger auf ein Null-terminierte Zeichenarray, das String(Char*) oder String(Char*, Int32, Int32) Konstruktor.From a pointer to a null-terminated character array, by using the String(Char*) or String(Char*, Int32, Int32) constructor. Entweder das gesamte Array oder einem angegebenen Bereich kann verwendet werden, um die Zeichenfolge zu initialisieren.Either the entire array or a specified range can be used to initialize the string. Der Konstruktor kopiert eine Sequenz von Unicode-Zeichen ab, aus dem angegebenen Zeiger oder der angegebene Zeiger plus startIndex und bis zum Ende des Arrays oder für length Zeichen.The constructor copies a sequence of Unicode characters starting from the specified pointer or from the specified pointer plus startIndex and continuing to the end of the array or for length characters. Wenn value ist ein null-Zeiger oder length 0 (null), wird der Konstruktor erstellt eine Zeichenfolge, deren Wert String.Empty.If value is a null pointer or length is zero, the constructor creates a string whose value is String.Empty. Wenn der Kopiervorgang wird, bis zum Ende des Arrays fortgesetzt, und das Array ist nicht für die Null-terminiert, ist das Verhalten der Konstruktor System abhängig.If the copy operation proceeds to the end of the array and the array is not null-terminated, the constructor behavior is system-dependent. Eine solche Bedingung kann eine zugriffsverletzung verursachen.Such a condition might cause an access violation.

    Wenn das Array eingebetteten Null-Zeichen enthält (U + 0000 oder '\0') und die String(Char*, Int32, Int32) Überladung aufgerufen wird, wird die Zeichenfolgeninstanz enthält length Zeichen einschließlich aller eingebettete NULL-Werte.If the array contains any embedded null characters (U+0000 or '\0') and the String(Char*, Int32, Int32) overload is called, the string instance contains length characters including any embedded nulls. Das folgende Beispiel zeigt, was geschieht, wenn ein Zeiger auf ein Array aus 10 Elementen, die zwei Null-Zeichen enthält, übergeben, wird die String(Char*, Int32, Int32) Methode.The following example shows what happens when a pointer to an array of 10 elements that includes two null characters is passed to the String(Char*, Int32, Int32) method. Da die Adresse der Anfang des Arrays ist und alle Elemente im Array der Zeichenfolge hinzugefügt werden, instanziiert der Konstruktor eine Zeichenfolge mit zehn Zeichen, einschließlich der zwei eingebettete NULL-Werte.Because the address is the beginning of the array and all elements in the array are to be added to the string, the constructor instantiates a string with ten characters, including two embedded nulls. Andererseits, wenn dasselbe Array übergeben wird, um die String(Char*) -Konstruktor, der das Ergebnis ist eine vier-Zeichenfolge, die keine erste Null-Zeichen enthält.On the other hand, if the same array is passed to the String(Char*) constructor, the result is a four-character string that does not include the first null character.

    using namespace System;
    
    void main()
    {
       wchar_t chars[] = { L'a', L'b', L'c', L'd', L'\0', L'A', L'B', 
                           L'C', L'D', L'\0' };
       Char* chPtr = chars;
       String^ s = gcnew String(chPtr, 0, 
                                sizeof(chars) / sizeof (wchar_t));            
       for each (Char ch in s)
          Console::Write("{0:X4} ", Convert::ToUInt16(ch));
       Console::WriteLine();
       
       s = gcnew String(chPtr);         
       
       for each (Char ch in s)
          Console::Write("{0:X4} ", Convert::ToUInt16(ch));
       Console::WriteLine();    
    }
    // The example displays the following output:
    //       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
    //       0061 0062 0063 0064
    
    using System;
    
    public class Example
    {
       public unsafe static void Main()
       {
          char[] chars = { 'a', 'b', 'c', 'd', '\0', 'A', 'B', 'C', 'D', '\0' };
          string s = null;
          
          fixed(char* chPtr = chars) {
             s = new string(chPtr, 0, chars.Length);            
          } 
    
          foreach (var ch in s)
             Console.Write("{0:X4} ", Convert.ToUInt16(ch));
          Console.WriteLine();
          
          fixed(char* chPtr = chars) {
             s = new string(chPtr);         
          }
          
          foreach (var ch in s)
             Console.Write("{0:X4} ", Convert.ToUInt16(ch));
          Console.WriteLine();    
       }
    }
    // The example displays the following output:
    //       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
    //       0061 0062 0063 0064
    

    Das Array muss es sich um Unicode-Zeichen enthalten.The array must contain Unicode characters. In C++wird in diesem Dies bedeutet, dass das Zeichenarray muss definiert werden entweder als die verwaltete Char[]-Typ oder die nicht verwaltetewchar_t[]-Typ.In C++, this means that the character array must be defined either as the managed Char[] type or the unmanagedwchar_t[] type.

    Wenn die String(Char*) -Überladung aufgerufen wird und das Array ist nicht für die Null-terminiert ist, oder wenn die String(Char*, Int32, Int32) -Überladung aufgerufen wird und startIndex + length-1 umfasst eine Reihe, die sie außerhalb des Speichers für die Sequenz von Zeichen zugeordnet das Verhalten des Konstruktors ist systemabhängig und eine zugriffsverletzung auftreten.If the String(Char*) overload is called and the array is not null-terminated, or if the String(Char*, Int32, Int32) overload is called and startIndex + length-1 includes a range that it outside the memory allocated for the sequence of characters, the behavior of the constructor is system-dependent, and an access violation may occur. Darüber hinaus auf dem Intel Itanium-Prozessor aufgerufen, um die String(Char*, Int32, Int32) Konstruktor löst möglicherweise eine DataMisalignedException Ausnahme.In addition, on the Intel Itanium processor, calls to the String(Char*, Int32, Int32) constructor may throw a DataMisalignedException exception. In diesem Fall rufen die String(Char[], Int32, Int32) stattdessen.If this occurs, call the String(Char[], Int32, Int32) instead.

  • Von einem Zeiger auf ein Array von Byte mit Vorzeichen.From a pointer to a signed byte array. Entweder das gesamte Array oder einem angegebenen Bereich kann verwendet werden, um die Zeichenfolge zu initialisieren.Either the entire array or a specified range can be used to initialize the string. Die Abfolge von Bytes mit der Standardcodepage-Codierung interpretiert werden kann, oder eine Codierung im Konstruktoraufruf angegeben werden.The sequence of bytes can be interpreted by using the default code page encoding, or an encoding can be specified in the constructor call. Wenn der Konstruktor versucht, eine Zeichenfolge aus einem gesamten Array zu instanziieren, der keine Null-terminiert ist, oder wenn der Bereich der Arrays von value + startIndex zu value + startIndex + length -1 ist, außerhalb des Arbeitsspeichers für das Array, das Verhalten dieses Konstruktors ist systemabhängig und eine zugriffsverletzung auftreten.If the constructor tries to instantiate a string from an entire array that is not null-terminated, or if the range of the array from value + startIndex to value + startIndex + length -1 is outside of the memory allocated for the array, the behavior of this constructor is system-dependent, and an access violation may occur.

    Die drei Konstruktoren, die als Parameter ein Bytearray mit Vorzeichen enthalten dienen in erster Linie zum Konvertieren einer C++ char array in eine Zeichenfolge, wie im folgenden Beispiel gezeigt:The three constructors that include a signed byte array as a parameter are designed primarily to convert a C++ char array to a string, as shown in this example:

    using namespace System;
    
    void main()
    {
          char chars[] = { 'a', 'b', 'c', 'd', '\x00' };
          
          char* charPtr = chars;
          String^ value = gcnew String(charPtr);
    
          Console::WriteLine(value);
    }
    // The example displays the following output:
    //      abcd
    

    Wenn das Array enthält Null-Zeichen ('\0') oder die Bytes, deren Wert 0 gleich, und der String(SByte*, Int32, Int32) Überladung aufgerufen wird, wird die Zeichenfolgeninstanz enthält length Zeichen einschließlich aller eingebettete NULL-Werte.If the array contains any null characters ('\0') or bytes whose value is 0 and the String(SByte*, Int32, Int32) overload is called, the string instance contains length characters including any embedded nulls. Das folgende Beispiel zeigt, was geschieht, wenn ein Zeiger auf ein Array aus 10 Elementen, die zwei Null-Zeichen enthält, übergeben, wird die String(SByte*, Int32, Int32) Methode.The following example shows what happens when a pointer to an array of 10 elements that includes two null characters is passed to the String(SByte*, Int32, Int32) method. Da die Adresse der Anfang des Arrays ist und alle Elemente im Array der Zeichenfolge hinzugefügt werden, instanziiert der Konstruktor eine Zeichenfolge mit zehn Zeichen, einschließlich der zwei eingebettete NULL-Werte.Because the address is the beginning of the array and all elements in the array are to be added to the string, the constructor instantiates a string with ten characters, including two embedded nulls. Andererseits, wenn dasselbe Array übergeben wird, um die String(SByte*) -Konstruktor, der das Ergebnis ist eine vier-Zeichenfolge, die keine erste Null-Zeichen enthält.On the other hand, if the same array is passed to the String(SByte*) constructor, the result is a four-character string that does not include the first null character.

    using namespace System;
    
    void main()
    {
       char bytes[] = { 0x61, 0x62, 0x063, 0x064, 0x00, 0x41, 0x42,0x43, 
                        0x44, 0x00 };
       
       char* bytePtr = bytes;
       String^ s = gcnew String(bytePtr, 0, sizeof(bytes) / sizeof (char));
       
       for each (Char ch in s)
          Console::Write("{0:X4} ", Convert::ToUInt16(ch));
       
       Console::WriteLine();
       
       s = gcnew String(bytePtr);
    
       for each (Char ch in s)
          Console::Write("{0:X4} ", Convert::ToUInt16(ch));
       Console::WriteLine();       
    }
    // The example displays the following output:
    //      0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
    //      0061 0062 0063 0064
    
    using System;
    
    public class Example
    {
       public unsafe static void Main()
       {
          sbyte[] bytes = { 0x61, 0x62, 0x063, 0x064, 0x00, 0x41, 0x42,0x43, 0x44, 0x00 };
          
          string s = null;
          fixed (sbyte* bytePtr = bytes) {
             s = new string(bytePtr, 0, bytes.Length);
          }
          
          foreach (var ch in s)
             Console.Write("{0:X4} ", Convert.ToUInt16(ch));
          
          Console.WriteLine();    
    
          fixed(sbyte* bytePtr = bytes) {
             s = new string(bytePtr);         
          }
          
          foreach (var ch in s)
             Console.Write("{0:X4} ", Convert.ToUInt16(ch));
          Console.WriteLine();    
    
       }
    }
    // The example displays the following output:
    //       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
    //       0061 0062 0063 0064
    

    Da die String(SByte*) und String(SByte*, Int32, Int32) Konstruktoren interpretieren value verwenden die Standard-ANSI-Codepage, diese Konstruktoren mit identischer Byte-Arrays aufrufen kann erstellen Zeichenfolgen, die auf anderen Systemen unterschiedliche Werte aufweisen.Because the String(SByte*) and String(SByte*, Int32, Int32) constructors interpret value by using the default ANSI code page, calling these constructors with identical byte arrays may create strings that have different values on different systems.

Behandlung von ZeichenfolgenHandling repetitive strings

Verwenden Sie Apps, die analysiert werden, oder Streams von Text häufig Decodieren der String(Char[], Int32, Int32) Konstruktor oder die StringBuilder.Append(Char[], Int32, Int32) Methode, um Sequenzen von Zeichen in eine Zeichenfolge zu konvertieren.Apps that parse or decode streams of text often use the String(Char[], Int32, Int32) constructor or the StringBuilder.Append(Char[], Int32, Int32) method to convert sequences of characters into a string. Erstellen neue Zeichenfolgen wiederholt mit den gleichen Wert anstatt zu erstellen und Wiederverwenden von einer Zeichenfolge wird Arbeitsspeicher vergeudet.Repeatedly creating new strings with the same value instead of creating and reusing one string wastes memory. Wenn Sie wahrscheinlich den gleichen Zeichenfolgenwert wiederholt zu erstellen, indem die String(Char[], Int32, Int32) Konstruktor, selbst wenn Sie nicht in kennen fahren Sie fort, was diese Werte identisch sein können, können Sie stattdessen eine Nachschlagetabelle verwenden.If you are likely to create the same string value repeatedly by calling the String(Char[], Int32, Int32) constructor, even if you don't know in advance what those identical string values may be, you can use a lookup table instead.

Nehmen wir beispielsweise an, Sie lesen und Analysieren einen Stream von Zeichen aus einer Datei, die XML-Tags und Attribute enthält.For example, suppose you read and parse a stream of characters from a file that contains XML tags and attributes. Wenn Sie den Stream zu analysieren, treten wiederholt bestimmte Token (d. h. Sequenzen von Zeichen, die eine symbolische Bedeutung haben).When you parse the stream, you repeatedly encounter certain tokens (that is, sequences of characters that have a symbolic meaning). Token, die die Zeichenfolgen "0", "1", "true" und "false" werden wahrscheinlich in einem XML-Stream häufig auftreten.Tokens equivalent to the strings "0", "1", "true", and "false" are likely to occur frequently in an XML stream.

Nicht jedes Token in einer neuen Zeichenfolge zu konvertieren, können Sie erstellen eine System.Xml.NameTable Objekt, das häufig auftretende Zeichenfolgen.Instead of converting each token into a new string, you can create a System.Xml.NameTable object to hold commonly occurring strings. Die NameTable -Objekt verbessert die Leistung, da es sich um gespeicherten Zeichenfolgen abruft, ohne den temporären Speicher zuzuordnen.The NameTable object improves performance, because it retrieves stored strings without allocating temporary memory. Wenn Sie ein Token auftritt, verwenden Sie die NameTable.Get(Char[], Int32, Int32) Methode, um das Token aus der Tabelle abzurufen.When you encounter a token, use the NameTable.Get(Char[], Int32, Int32) method to retrieve the token from the table. Wenn das Token vorhanden ist, gibt die Methode die entsprechende Zeichenfolge zurück.If the token exists, the method returns the corresponding string. 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 abgerufen.If the token does not exist, use the NameTable.Add(Char[], Int32, Int32) method to insert the token into the table and to get the corresponding string.

Beispiel 1: Mit der Zeichenfolge-ZuweisungExample 1: Using string assignment

Das folgende Beispiel erstellt eine neue Zeichenfolge, indem Sie ihm ein Zeichenfolgenliteral zuweisen.The following example creates a new string by assigning it a string literal. Es erstellt eine zweite Zeichenfolge an, indem Sie den Wert der ersten Zeichenfolge zuweisen.It creates a second string by assigning the value of the first string to it. Hierbei handelt es sich um die beiden am häufigsten verwendeten Arten zum Instanziieren einer neuen String Objekt.These are the two most common ways to instantiate a new String object.

using namespace System;

void main()
{
   String^ value1 = L"This is a string.";
   String^ value2 = value1;
   Console::WriteLine(value1);
   Console::WriteLine(value2);
}
// The example displays the following output:
//    This is a string.
//    This is a string.
using System;

public class Example
{
   public static void Main()
   {
      String value1 = "This is a string.";
      String value2 = value1;
      Console.WriteLine(value1);
      Console.WriteLine(value2);
   }
}
// The example displays the following output:
//    This is a string.
//    This is a string.
Module Example
   Public Sub Main()
      Dim value1 As String = "This is a string."
      Dim value2 As String = value1
      Console.WriteLine(value1)
      Console.WriteLine(value2)
   End Sub
End Module
' The example displays the following output:
'    This is a string.
'    This is a string.

Beispiel 2: Verwenden ein Array von ZeichenExample 2: Using a character array

Im folgende Beispiel wird veranschaulicht, wie zum Erstellen eines neuen String Objekt aus einem Zeichenarray.The following example demonstrates how to create a new String object from a character array.

// Unicode Mathematical operators
wchar_t charArray1[4] = {L'\x2200',L'\x2202',L'\x200F',L'\x2205'};
wchar_t * lptstr1 =  &charArray1[ 0 ];
String^ wszMathSymbols = gcnew String( lptstr1 );

// Unicode Letterlike Symbols
wchar_t charArray2[4] = {L'\x2111',L'\x2118',L'\x2122',L'\x2126'};
wchar_t * lptstr2 =  &charArray2[ 0 ];
String^ wszLetterLike = gcnew String( lptstr2 );

// Compare Strings - the result is false
Console::WriteLine( String::Concat( L"The Strings are equal? ", (0 == String::Compare( wszLetterLike, wszMathSymbols ) ? (String^)"TRUE" : "FALSE") ) );
// Unicode Mathematical operators
char [] charArr1 = {'\u2200','\u2202','\u200F','\u2205'};
String szMathSymbols = new String(charArr1);

// Unicode Letterlike Symbols
char [] charArr2 = {'\u2111','\u2118','\u2122','\u2126'};
String szLetterLike = new String (charArr2);

// Compare Strings - the result is false
Console.WriteLine("The Strings are equal? " +
    (String.Compare(szMathSymbols, szLetterLike)==0?"true":"false") );
' Unicode Mathematical operators
Dim charArr1() As Char = {ChrW(&H2200), ChrW(&H2202), _
                          ChrW(&H200F), ChrW(&H2205)}
Dim szMathSymbols As New String(charArr1)

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

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

Beispiel 3: Verwenden einen Teil eines Arrays von Zeichen, und wiederholen ein einzelnes ZeichenExample 3: Using a portion of a character array and repeating a single character

Im folgende Beispiel wird veranschaulicht, wie zum Erstellen eines neuen String Objekt aus einem Abschnitt der ein Array von Zeichen und das Erstellen eines neuen String -Objekt, das mehrere Vorkommen eines einzelnen Zeichens enthält.The following example demonstrates how to create a new String object from a portion of a character array, and how to create a new String object that contains multiple occurrences of a single character.

// Create a Unicode String with 5 Greek Alpha characters
String^ szGreekAlpha = gcnew String( L'\x0391',5 );

// Create a Unicode String with a Greek Omega character
wchar_t charArray5[3] = {L'\x03A9',L'\x03A9',L'\x03A9'};
String^ szGreekOmega = gcnew String( charArray5,2,1 );
String^ szGreekLetters = String::Concat( szGreekOmega, szGreekAlpha, szGreekOmega->Clone() );

// Examine the result
Console::WriteLine( szGreekLetters );

// The first index of Alpha
int ialpha = szGreekLetters->IndexOf( L'\x0391' );

// The last index of Omega
int iomega = szGreekLetters->LastIndexOf( L'\x03A9' );
Console::WriteLine( String::Concat(  "The Greek letter Alpha first appears at index ", Convert::ToString( ialpha ) ) );
Console::WriteLine( String::Concat(  " and Omega last appears at index ", Convert::ToString( iomega ),  " in this String." ) );
// Create a Unicode String with 5 Greek Alpha characters
String szGreekAlpha = new String('\u0391',5);
// Create a Unicode String with a Greek Omega character
String szGreekOmega = new String(new char [] {'\u03A9','\u03A9','\u03A9'},2,1);

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

// Examine the result
Console.WriteLine(szGreekLetters);

// The first index of Alpha
int ialpha = szGreekLetters.IndexOf('\u0391');
// The last index of Omega
int iomega = szGreekLetters.LastIndexOf('\u03A9');

Console.WriteLine("The Greek letter Alpha first appears at index " + ialpha +
    " and Omega last appears at index " + iomega + " in this String.");
' Create a Unicode String with 5 Greek Alpha characters
Dim szGreekAlpha As New String(ChrW(&H0391), 5)
' Create a Unicode String with a Greek Omega character
Dim szGreekOmega As New String(New Char() {ChrW(&H03A9), ChrW(&H03A9), _
                                           ChrW(&H03A9)}, 2, 1)

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

' Examine the result
Console.WriteLine(szGreekLetters)

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

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

Beispiel 4: Mithilfe eines Zeigers auf ein Array von ZeichenExample 4: Using a pointer to a character array

Im folgende Beispiel wird veranschaulicht, wie zum Erstellen eines neuen String Objekt von einem Zeiger auf ein Array von Zeichen.The following example demonstrates how to create a new String object from a pointer to an array of characters. C#-Beispiel muss kompiliert werden, mithilfe der /unsafe Compilerschalter.The C# example must be compiled by using the /unsafe compiler switch.

using namespace System;

void main()
{
   wchar_t characters[] = {L'H',L'e',L'l',L'l',L'o',L' ', 
                           L'W',L'o',L'r',L'l',L'd',L'!',L'\x0000'};

   Char* charPtr = characters;
   String^ value = gcnew String(charPtr);
   Console::WriteLine(value);
}
// The example displays the following output:
//        Hello world!
using System;

public class Example
{
   public static unsafe void Main()
   {
      char[] characters = { 'H', 'e', 'l', 'l', 'o', ' ', 
                            'w', 'o', 'r', 'l', 'd', '!', '\u0000' };
      string value;
      
      fixed (char* charPtr = characters) {
         value = new String(charPtr);
      }                            
      Console.WriteLine(value);
   }
}
// The example displays the following output:
//        Hello world!

Beispiel 5: Instanziieren eine Zeichenfolge von einem Zeiger und einen Bereich eines ArraysExample 5: Instantiating a string from a pointer and a range of an array

Im folgende Beispiel werden die Elemente eines Arrays von Zeichen für einen Zeitraum oder ein Ausrufezeichen untersucht.The following example examines the elements of a character array for either a period or an exclamation point. Wenn eines gefunden wird, instanziiert er eine Zeichenfolge aus den Zeichen im Array, die das interpunktionssymbol vorangestellt sein.If one is found, it instantiates a string from the characters in the array that precede the punctuation symbol. Wenn dies nicht der Fall ist, wird er instanziiert eine Zeichenfolge mit den gesamten Inhalt des Arrays.If not, it instantiates a string with the entire contents of the array. C#-Beispiel muss kompiliert werden, mithilfe der /unsafe Compilerschalter.The C# example must be compiled using the /unsafe compiler switch.

using namespace System;


void main()
{
   wchar_t characters[] = {L'H',L'e',L'l',L'l',L'o',L' ', 
                           L'W',L'o',L'r',L'l',L'd',L'!',L'\x0000'};

   Char* charPtr = characters;
   int length = 0;
   Char* iterator = charPtr;

   while (*iterator != '\x0000')
   {
      if (*iterator == L'!' || *iterator == L'.')
         break;
      *iterator++;
      length++;
   }
   String^ value = gcnew String(charPtr, 0, length);
   Console::WriteLine(value);
}
// The example displays the following output:
//      Hello World
using System;

public class Example
{
   public static unsafe void Main()
   {
      char[] characters = { 'H', 'e', 'l', 'l', 'o', ' ', 
                            'w', 'o', 'r', 'l', 'd', '!', '\u0000' };
      String value;
      
      fixed (char* charPtr = characters) {
         int length = 0;
         Char* iterator = charPtr;
   
         while (*iterator != '\x0000')
         {
            if (*iterator == '!' || *iterator == '.')
               break;
            iterator++;
            length++;
         }
         value = new String(charPtr, 0, length);
      }
      Console.WriteLine(value);
   }
}
// The example displays the following output:
//      Hello World

Beispiel 6: Instanziieren eine Zeichenfolge von einem Zeiger auf ein Array von Byte mit VorzeichenExample 6: Instantiating a string from a pointer to a signed byte array

Im folgende Beispiel wird veranschaulicht, wie Sie eine Instanz von erstellen können die String -Klasse mit der String(SByte*) Konstruktor.The following example demonstrates how you can create an instance of the String class with the String(SByte*) constructor.

// Null terminated ASCII characters in a simple char array
char charArray3[4] = {0x41,0x42,0x43,0x00};
char * pstr3 =  &charArray3[ 0 ];
String^ szAsciiUpper = gcnew String( pstr3 );
char charArray4[4] = {0x61,0x62,0x63,0x00};
char * pstr4 =  &charArray4[ 0 ];
String^ szAsciiLower = gcnew String( pstr4,0,sizeof(charArray4) );

// Prints "ABC abc"
Console::WriteLine( String::Concat( szAsciiUpper,  " ", szAsciiLower ) );

// Compare Strings - the result is true
Console::WriteLine( String::Concat(  "The Strings are equal when capitalized ? ", (0 == String::Compare( szAsciiUpper->ToUpper(), szAsciiLower->ToUpper() ) ? (String^)"TRUE" :  "FALSE") ) );

// This is the effective equivalent of another Compare method, which ignores case
Console::WriteLine( String::Concat(  "The Strings are equal when capitalized ? ", (0 == String::Compare( szAsciiUpper, szAsciiLower, true ) ? (String^)"TRUE" :  "FALSE") ) );
unsafe
{
    // Null terminated ASCII characters in an sbyte array
    String szAsciiUpper = null;
    sbyte[] sbArr1 = new sbyte[] { 0x41, 0x42, 0x43, 0x00 };
    // Instruct the Garbage Collector not to move the memory
    fixed(sbyte* pAsciiUpper = sbArr1)
    {
        szAsciiUpper = new String(pAsciiUpper);
    }
    String szAsciiLower = null;
    sbyte[] sbArr2 = { 0x61, 0x62, 0x63, 0x00 };
    // Instruct the Garbage Collector not to move the memory
    fixed(sbyte* pAsciiLower = sbArr2)
    {
        szAsciiLower = new String(pAsciiLower, 0, sbArr2.Length);
    }
    // Prints "ABC abc"
    Console.WriteLine(szAsciiUpper + " " + szAsciiLower);

    // Compare Strings - the result is true
    Console.WriteLine("The Strings are equal when capitalized ? " +
        (String.Compare(szAsciiUpper.ToUpper(), szAsciiLower.ToUpper())==0?"true":"false") );

    // This is the effective equivalent of another Compare method, which ignores case
    Console.WriteLine("The Strings are equal when capitalized ? " +
        (String.Compare(szAsciiUpper, szAsciiLower, true)==0?"true":"false") );
}

VersionsinformationenVersion information

.NET Framework.NET Framework
Alle Überladungen werden unterstützt: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0All overloads are supported in: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile.NET Framework Client Profile
Alle Überladungen werden unterstützt: 4 3.5 SP1All overloads are supported in: 4, 3.5 SP1

Portable KlassenbibliothekPortable Class Library
Alle Überladungen ohne eine SByte * Parameter werden unterstützt.All overloads without an SByte* parameter are supported

.NET für Windows Store-Apps.NET for Windows Store apps
Alle Überladungen ohne eine SByte * Parameter werden unterstützt: Windows 8All overloads without an SByte* parameter are supported in: Windows 8

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

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

Parameter

value
Char*

Ein Zeiger auf ein mit Null endendes Array von Unicode-Zeichen.A pointer to a null-terminated array of Unicode characters.

Ausnahmen

Der aktuelle Prozess hat keinen Lesezugriff auf alle adressierten Zeichen.The current process does not have read access to all the addressed characters.

value gibt ein Array an, das ein ungültiges Unicode-Zeichen enthält, oder value gibt eine Adresse kleiner als 64000 an.value specifies an array that contains an invalid Unicode character, or value specifies an address less than 64000.

Hinweise

Hinweis

Beispiele und eine umfassende von Nutzungsinformationen zu diesem und anderen String Konstruktorüberladungen, finden Sie unter den String Konstruktor Zusammenfassung.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Sicherheit

SecurityCriticalAttribute
erfordert volle Vertrauenswürdigkeit für den unmittelbaren Aufrufer.requires full trust for the immediate caller. Dieser Member kann nicht von teilweise vertrauenswürdigem oder transparentem Code verwendet werden.This member cannot be used by partially trusted or transparent code.

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

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

Parameter

value
SByte*

Ein Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen.A pointer to an array of 8-bit signed integers. Die Ganzzahlen werden mit der aktuellen Systemcodeseiten-Codierung interpretiert (d.h. der durch Default angegebenen Codierung).The integers are interpreted using the current system code page encoding (that is, the encoding specified by Default).

startIndex
Int32 Int32 Int32 Int32

Die Anfangsposition in value.The starting position within value.

length
Int32 Int32 Int32 Int32

Die Anzahl der aus value zu verwendenden Zeichen.The number of characters within value to use.

Ausnahmen

startIndex oder length ist kleiner als 0.startIndex or length is less than zero.

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

- oder --or- Die Länge der zu initialisierenden neuen Zeichenfolge ist zu groß und kann daher nicht zugeordnet werden.The length of the new string to initialize is too large to allocate.

Die durch value + startIndex angegebene Adresse ist kleiner als 64K.The address specified by value + startIndex is less than 64K.

- oder --or- Eine neue Instanz von String konnte nicht mit value initialisiert werden, wobei angenommen wurde, dass value in ANSI codiert ist.A new instance of String could not be initialized using value, assuming value is encoded in ANSI.

value, startIndex und length geben zusammen eine ungültige Adresse an.value, startIndex, and length collectively specify an invalid address.

Hinweise

Hinweis

Beispiele und eine umfassende von Nutzungsinformationen zu diesem und anderen String Konstruktorüberladungen, finden Sie unter den String Konstruktor Zusammenfassung.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Sicherheit

SecurityCriticalAttribute
erfordert volle Vertrauenswürdigkeit für den unmittelbaren Aufrufer.requires full trust for the immediate caller. Dieser Member kann nicht von teilweise vertrauenswürdigem oder transparentem Code verwendet werden.This member cannot be used by partially trusted or transparent code.

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

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

public:
 String(cli::array <char> ^ value, int startIndex, int length);
public String (char[] value, int startIndex, int length);
new string : char[] * int * int -> string
Public Sub New (value As Char(), startIndex As Integer, length As Integer)

Parameter

value
Char[]

Ein Array von Unicode-Zeichen.An array of Unicode characters.

startIndex
Int32 Int32 Int32 Int32

Die Anfangsposition in value.The starting position within value.

length
Int32 Int32 Int32 Int32

Die Anzahl der aus value zu verwendenden Zeichen.The number of characters within value to use.

Ausnahmen

startIndex oder length ist kleiner als 0.startIndex or length is less than zero.

- oder --or- Die Summe von startIndex und length ist größer als die Anzahl von Elementen in value.The sum of startIndex and length is greater than the number of elements in value.

Hinweise

Hinweis

Beispiele und eine umfassende von Nutzungsinformationen zu diesem und anderen String Konstruktorüberladungen, finden Sie unter den String Konstruktor Zusammenfassung.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

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

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

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

Parameter

value
Char*

Ein Zeiger auf ein Array von Unicode-Zeichen.A pointer to an array of Unicode characters.

startIndex
Int32 Int32 Int32 Int32

Die Anfangsposition in value.The starting position within value.

length
Int32 Int32 Int32 Int32

Die Anzahl der aus value zu verwendenden Zeichen.The number of characters within value to use.

Ausnahmen

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

value gibt ein Array an, das ein ungültiges Unicode-Zeichen enthält, oder value + startIndex gibt eine Adresse kleiner als 64000 an.value specifies an array that contains an invalid Unicode character, or value + startIndex specifies an address less than 64000.

Hinweise

Hinweis

Beispiele und eine umfassende von Nutzungsinformationen zu diesem und anderen String Konstruktorüberladungen, finden Sie unter den String Konstruktor Zusammenfassung.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Sicherheit

SecurityCriticalAttribute
erfordert volle Vertrauenswürdigkeit für den unmittelbaren Aufrufer.requires full trust for the immediate caller. Dieser Member kann nicht von teilweise vertrauenswürdigem oder transparentem Code verwendet werden.This member cannot be used by partially trusted or transparent code.

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

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

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

Parameter

value
SByte*

Ein Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen.A pointer to an array of 8-bit signed integers.

startIndex
Int32 Int32 Int32 Int32

Die Anfangsposition in value.The starting position within value.

length
Int32 Int32 Int32 Int32

Die Anzahl der aus value zu verwendenden Zeichen.The number of characters within value to use.

enc
Encoding Encoding Encoding Encoding

Ein Objekt, das angibt, wie das Array codiert ist, auf das value verweist.An object that specifies how the array referenced by value is encoded. Wenn encnull ist, wird von ANSI-Codierung ausgegangen.If enc is null, ANSI encoding is assumed.

Ausnahmen

startIndex oder length ist kleiner als 0.startIndex or length is less than zero.

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

- oder --or- Die Länge der zu initialisierenden neuen Zeichenfolge ist zu groß und kann daher nicht zugeordnet werden.The length of the new string to initialize is too large to allocate.

Die durch value + startIndex angegebene Adresse ist kleiner als 64K.The address specified by value + startIndex is less than 64K.

- oder --or- Eine neue Instanz von String konnte nicht mit value initialisiert werden, wobei angenommen wurde, dass value entsprechend der Angabe durch enc codiert ist.A new instance of String could not be initialized using value, assuming value is encoded as specified by enc.

value, startIndex und length geben zusammen eine ungültige Adresse an.value, startIndex, and length collectively specify an invalid address.

Hinweise

Hinweis

Beispiele und eine umfassende von Nutzungsinformationen zu diesem und anderen String Konstruktorüberladungen, finden Sie unter den String Konstruktor Zusammenfassung.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Sicherheit

SecurityCriticalAttribute
erfordert volle Vertrauenswürdigkeit für den unmittelbaren Aufrufer.requires full trust for the immediate caller. Dieser Member kann nicht von teilweise vertrauenswürdigem oder transparentem Code verwendet werden.This member cannot be used by partially trusted or transparent code.

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

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

Parameter

value
SByte*

Ein Zeiger auf ein mit NULL endendes Array von 8-Bit-Ganzzahlen mit Vorzeichen.A pointer to a null-terminated array of 8-bit signed integers. Die Ganzzahlen werden mit der aktuellen Systemcodeseiten-Codierung interpretiert (d.h. der durch Default angegebenen Codierung).The integers are interpreted using the current system code page encoding (that is, the encoding specified by Default).

Ausnahmen

Eine neue Instanz von String konnte nicht mit value initialisiert werden, wobei angenommen wurde, dass value in ANSI codiert ist.A new instance of String could not be initialized using value, assuming value is encoded in ANSI.

Die Länge der neuen zu initialisierenden Zeichenfolge, die durch das NULL-Abschlusszeichen von value bestimmt wird, ist zu groß für die Zuordnung.The length of the new string to initialize, which is determined by the null termination character of value, is too large to allocate.

value gibt eine ungültige Adresse an.value specifies an invalid address.

Hinweise

Hinweis

Beispiele und eine umfassende von Nutzungsinformationen zu diesem und anderen String Konstruktorüberladungen, finden Sie unter den String Konstruktor Zusammenfassung.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Sicherheit

SecurityCriticalAttribute
erfordert volle Vertrauenswürdigkeit für den unmittelbaren Aufrufer.requires full trust for the immediate caller. Dieser Member kann nicht von teilweise vertrauenswürdigem oder transparentem Code verwendet werden.This member cannot be used by partially trusted or transparent code.

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

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

Parameter

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

Initialisiert eine neue Instanz der String-Klasse mit dem durch ein Array von Unicode-Zeichen angegebenen Wert.Initializes a new instance of the String class to the value indicated by an array of Unicode characters.

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

Parameter

value
Char[]

Ein Array von Unicode-Zeichen.An array of Unicode characters.

Hinweise

Hinweis

Beispiele und eine umfassende von Nutzungsinformationen zu diesem und anderen String Konstruktorüberladungen, finden Sie unter den String Konstruktor Zusammenfassung.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

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

public:
 String(char c, int count);
public String (char c, int count);
new string : char * int -> string
Public Sub New (c As Char, count As Integer)

Parameter

c
Char Char Char Char

Ein Unicode-Zeichen.A Unicode character.

count
Int32 Int32 Int32 Int32

Die Anzahl des Vorkommens von c.The number of times c occurs.

Ausnahmen

Hinweise

Hinweis

Beispiele und eine umfassende von Nutzungsinformationen zu diesem und anderen String Konstruktorüberladungen, finden Sie unter den String Konstruktor Zusammenfassung.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Gilt für: