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:

Syntax für überladene Konstruktoren Overloaded constructor syntax
Metern Parameters
Ausnahmen Exceptions
Welche Methode rufe ich auf? Which method do I call?
Erstellen von Zeichen folgen Creating strings
Behandeln wiederholter Zeichen folgen Handling repetitive strings
Beispiele für das Instanziieren von Zeichen folgen:Examples of instantiating strings:
Verwenden der Zeichen folgen ZuweisungUsing string assignment
Verwenden eines Zeichen ArraysUsing a character array
Verwenden eines Teils eines Zeichen Arrays und Wiederholen eines einzelnen ZeichensUsing a portion of a character array and repeating a single character
Verwenden eines Zeigers auf ein Zeichen ArrayUsing a pointer to a character array
Verwenden eines Zeigers und eines Bereichs eines ArraysUsing a pointer and a range of an array
Verwenden eines Zeigers auf ein Bytearray mit VorzeichenUsing a pointer to a signed byte array
VersionsinformationenVersion information

Syntax für überladene KonstruktorenOverloaded constructor syntax

Zeichenfolgenkonstruktoren werden in zwei Kategorien unterteilt: solche ohne Zeiger Parameter und solche mit Zeiger Parametern.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 unterstützt Visual Basic nicht die Verwendung von Zeigern und C# erfordert Code, der Zeiger verwendet, um in einem unsicheren Kontext ausgeführt zu werden.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 auf?For additional guidance on choosing an overload, see Which method do I call?

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

String(Char[] value, Int32 startIndex, Int32 length)
Initialisiert die neue-Instanz mit dem Wert, der durch ein Array von Unicode-Zeichen, die Position des ersten Zeichens innerhalb dieses Arrays und eine Länge (z. b.) angegeben wird.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)
Initialisiert die neue Instanz mit dem Wert, der durch ein angegebenes Unicode-Zeichen angegeben wird, dasso oft wieangegeben wiederholt wird (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, der durch einen Zeiger auf ein Array von Unicode-Zeichen angegeben wird, das durch ein NULL-Zeichen (U + 0000 oder ' \ 0 ') beendet wird.(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: SecurityCriticalAttributeerfordert 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, der durch einen Zeiger auf ein Array von Unicode-Zeichen, die Position des ersten Zeichens innerhalb dieses Arrays und eine Länge angegeben wird.(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- value Zeichen ab dem startIndex Index und endet bei startIndex index + length -1 (z. b.).The constructor copies the Unicode characters from value starting at index startIndex and ending at index startIndex + length - 1 (example).

Berechtigung: SecurityCriticalAttributeerfordert 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, der durch einen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen angegeben wird.(Not CLS-compliant) Initializes the new instance to the value indicated by a pointer to an array of 8-bit signed integers. Es wird davon ausgegangen, dass das Array eine Zeichenfolge darstellt, die mithilfe der aktuellen System Codepage codiert ist Encoding.Default(d. h. die durch angegebene Codierung).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 ab value dem vom Zeiger angegebenen Speicherort, bis ein NULL-Zeichen (0x00) 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: SecurityCriticalAttributeerfordert 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 mit dem Wert, der durch einen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen, die Startposition innerhalb dieses Arrays und eine Länge angegeben wird.(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. Es wird davon ausgegangen, dass das Array eine Zeichenfolge darstellt, die mithilfe der aktuellen System Codepage codiert ist Encoding.Default(d. h. die durch angegebene Codierung).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 ab dem Wert startIndex , beginnend bei startIndex und endet + bei length -1 (z. b.).The constructor processes characters from value starting at startIndex and ending at startIndex + length - 1 (example).

Berechtigung: SecurityCriticalAttributeerfordert 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, der durch einen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen, eine Startposition innerhalb dieses Arrays, eine Encoding Länge und ein-Objekt angegeben wird.(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: SecurityCriticalAttributeerfordert 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

Im folgenden finden Sie eine komplette Liste der Parameter String , die von Konstruktoren verwendet werden, die keinen Zeiger Parameter enthalten.Here is a complete list of parameters used by String constructors that don't include a pointer parameter. Informationen zu den von den einzelnen über Ladungen verwendeten Parametern finden Sie in der obigen Überladungs Syntax.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 , die in der neuen Zeichenfolge enthalten sein sollen.The number of characters in value to include in the new string.

Standardwert:Array.LengthDefault value: Array.Length
count Int32 Gibt an, wie oft das c Zeichen in der neuen Zeichenfolge wiederholt wird.The number of times the character c is repeated in the new string. Wenn count 0 (null) ist, ist String.Emptyder Wert des neuen-Objekts.If count is zero, the value of the new object is String.Empty.

Im folgenden finden Sie eine komplette Liste der Parameter String , die von Konstruktoren verwendet werden, die einen Zeiger Parameter enthalten.Here is a complete list of parameters used by String constructors that include a pointer parameter. Informationen zu den von den einzelnen über Ladungen verwendeten Parametern finden Sie in der obigen Überladungs Syntax.For the parameters used by each overload, see the overload syntax above.

ParameterParameter TypType BeschreibungDescription
value Char*

- oder --or-

SByte*
Ein Zeiger auf ein 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 oder null ein leeres Array ist, ist String.Emptyder Wert der neuen Zeichenfolge.If value is null or an empty array, the value of the new string is String.Empty.
startIndex Int32 Der Index des Array Elements, das 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 Array Elemente, die zum Erstellen der neuen Zeichenfolge verwendet werden sollen.The number of array elements to use to create the new string. Wenn die Länge 0 (null) ist, erstellt der Konstruktor eine String.EmptyZeichenfolge, deren Wert ist.If length is zero, the constructor creates a string whose value is String.Empty.

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

Standardwert: Encoding.Defaultoder die aktuelle ANSI-Codepage des Systems.Default value: Encoding.Default, or the system's current ANSI code page

AusnahmenExceptions

Im folgenden finden Sie eine Liste der Ausnahmen, die von Konstruktoren ausgelöst werden, die keine Zeiger Parameter enthalten.Here's a list of exceptions thrown by constructors that don't include pointer parameters.

AusnahmeException BedingungCondition Ausgelöst vonThrown by
ArgumentNullException value ist null.value is null. String(Char[], Int32, Int32)
ArgumentOutOfRangeException startIndex,length odercount 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)

Im folgenden finden Sie eine Liste der Ausnahmen, die von Konstruktoren ausgelöst werden, die Zeiger Parameter einschließen.Here's a list of exceptions thrown by constructors that include pointer parameters.

AusnahmeException BedingungCondition Ausgelöst vonThrown by
ArgumentException valueGibt ein Array an, das ein ungültiges Unicode-Zeichen enthält.value specifies an array that contains an invalid Unicode character.

- oder --or-

valueoder value gibteineAdressestartIndex an, die kleiner als 64K ist. + value or value + startIndex specifies an address that is less than 64K.

- oder --or-

Eine neue String Instanz konnte nicht aus dem value Bytearray initialisiert werden value , da die Standard Code Page Codierung nicht verwendet.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ß, um zuzuordnen.The length of the new string is too large to allocate.
Alle Konstruktoren mit Zeigern.All constructors with pointers.
AccessViolationException value, oder value + -1 + , gibt eine ungültige Adresse an. startIndex lengthvalue, or value + startIndex + length - 1, specifies an invalid address. String(SByte*)

String(SByte*, Int32, Int32)

String(SByte*, Int32, Int32, Encoding)

Welche Methode rufe ich auf?Which method do I call?

BeschreibungTo Anrufen oder verwendenCall or use
Erstellen Sie eine Zeichenfolge.Create a string. Zuweisung eines Zeichenfolgenliterals oder einer vorhandenen Zeichenfolge (Beispiel)Assignment from a string literal or an existing string (example)
Erstellen Sie eine Zeichenfolge aus einem gesamten Zeichen Array.Create a string from an entire character array. String(Char[])(Beispiel)String(Char[]) (example)
Erstellen Sie eine Zeichenfolge aus einem Teil eines Zeichen Arrays.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 mehrmals wiederholt.Create a string that repeats the same character multiple times. String(Char, Int32)(Beispiel)String(Char, Int32) (example)
Erstellen Sie eine Zeichenfolge aus einem Zeiger auf ein Unicode-oder ein breit Zeichen Array.Create a string from a pointer to a Unicode or wide character array. String(Char*)
Erstellen Sie mithilfe des-Zeigers eine Zeichenfolge aus einem Teil eines Unicode-oder Wide Character-Arrays.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 C++ char aus einem-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 Zeichen folgenCreating strings

Das am häufigsten verwendete Verfahren zum programmgesteuerten Erstellen von Zeichen folgen ist eine einfache Zuweisung, wie in diesem Beispielveranschaulicht.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 Konstruktorüberladungen, mit denen Sie Zeichen folgen aus den folgenden Werten erstellen können:The String class also includes four types of constructor overloads that let you create strings from the following values:

  • Aus einem Zeichen Array (ein Array von UTF-16-codierten Zeichen).From a character array (an array of UTF-16-encoded characters). Sie können ein neues String -Objekt aus den Zeichen im gesamten Array oder einem Teil davon erstellen.You can create a new String object from the characters in the entire array or a portion of it. Der 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. Der String(Char[], Int32, Int32) Konstruktor kopiert die Zeichen aus dem startIndex Index in startIndex den Index + length -1 in 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 0 (null) ist, ist String.Emptyder Wert der neuen Zeichenfolge.If length is zero, the value of the new string is String.Empty.

    Wenn Ihr Code Zeichen folgen mit dem gleichen Wert wiederholt instanziiert, können Sie die Anwendungsleistung verbessern, indem Sie eine alternative Möglichkeit zum Erstellen von Zeichen folgen verwenden.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 Behandeln von Wiederkehrenden Zeichen folgen.For more information, see Handling repetitive strings.

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

  • Von einem Zeiger auf ein mit Null endendes Zeichen Array, mithilfe des String(Char*) - String(Char*, Int32, Int32) oder-Konstruktors.From a pointer to a null-terminated character array, by using the String(Char*) or String(Char*, Int32, Int32) constructor. Das gesamte Array oder ein angegebener 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, beginnend beim angegebenen Zeiger oder vom angegebenen Zeiger startIndex Plus und setzt das Ende des Arrays oder für length Zeichen fort.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 ein NULL-Zeiger ist length oder 0 (null) ist, erstellt der Konstruktor eine String.EmptyZeichenfolge, deren Wert ist.If value is a null pointer or length is zero, the constructor creates a string whose value is String.Empty. Wenn der Kopiervorgang bis zum Ende des Arrays verläuft und das Array nicht auf NULL endet, ist das konstruktorverhalten 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 eingebettete NULL-Zeichen (U + 0000 oder ' \ 0 ') enthält und String(Char*, Int32, Int32) die-Überladung aufgerufen wird, enthält length die Zeichen folgen Instanz Zeichen, einschließlich der eingebetteten Nullen.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 mit 10 Elementen, das zwei NULL-Zeichen enthält String(Char*, Int32, Int32) , an die-Methode übermittelt wird.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 es sich bei der Adresse um den Anfang des Arrays handelt und alle Elemente im Array der Zeichenfolge hinzugefügt werden sollen, instanziiert der Konstruktor eine Zeichenfolge mit zehn Zeichen, einschließlich zwei eingebetteter Nullen.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. Wenn das gleiche Array hingegen an den String(Char*) Konstruktor übergeben wird, ist das Ergebnis eine Zeichenfolge mit vier Zeichen, die das erste Null-Zeichen nicht 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 Unicode-Zeichen enthalten.The array must contain Unicode characters. In C++bedeutet dies, dass das Zeichen Array entweder als verwalteter Char[]-Typ oder als nicht verwalteterwchar_t[]-Typ definiert werden muss.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 nicht mit NULL endet, oder wenn die String(Char*, Int32, Int32) Überladung aufgerufen wird startIndexund + length-1 einen Bereich enthält, der außerhalb des für die Zeichenfolge zugeordneten Arbeitsspeichers liegt, das Verhalten des Konstruktors ist System abhängig, und es kann 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. Außerdem können Aufrufe des String(Char*, Int32, Int32) -Konstruktors auf dem Intel Itanium-Prozessor eine DataMisalignedException -Ausnahme auslösen.In addition, on the Intel Itanium processor, calls to the String(Char*, Int32, Int32) constructor may throw a DataMisalignedException exception. Wenn dies auftritt, müssen Sie String(Char[], Int32, Int32) stattdessen den-Befehl verwenden.If this occurs, call the String(Char[], Int32, Int32) instead.

  • Von einem Zeiger auf ein Bytearray mit Vorzeichen.From a pointer to a signed byte array. Das gesamte Array oder ein angegebener 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 Byte Sequenz kann mit der Standard Code Page Codierung interpretiert werden, oder es kann eine Codierung im konstruktorbefehl 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 ganzen Array zu instanziieren, das nicht mit NULL endet, oder, wenn der Bereich value des value Arrays von bis + + startIndex startIndex + length -1 befindet sich außerhalb des für das Array zugeordneten Arbeitsspeichers, das Verhalten dieses Konstruktors ist System abhängig, und es kann 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 ein Bytearray mit Vorzeichen als Parameter enthalten, werden in erster C++ char Linie so entworfen, dass ein Array in eine Zeichenfolge konvertiert wird, 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 NULL Zeichen (' \ 0 ') oder Bytes enthält, deren Wert 0 ist, und String(SByte*, Int32, Int32) die-Überladung aufgerufen wird, enthält length die Zeichen folgen Instanz Zeichen, einschließlich der eingebetteten Nullen.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 mit 10 Elementen, das zwei NULL-Zeichen enthält String(SByte*, Int32, Int32) , an die-Methode übermittelt wird.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 es sich bei der Adresse um den Anfang des Arrays handelt und alle Elemente im Array der Zeichenfolge hinzugefügt werden sollen, instanziiert der Konstruktor eine Zeichenfolge mit zehn Zeichen, einschließlich zwei eingebetteter Nullen.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. Wenn das gleiche Array hingegen an den String(SByte*) Konstruktor übergeben wird, ist das Ergebnis eine Zeichenfolge mit vier Zeichen, die das erste Null-Zeichen nicht 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 der String(SByte*) - String(SByte*, Int32, Int32) Konstruktor und value der-Konstruktor mit der standardmäßigen ANSI-Codepage interpretieren, können beim Aufrufen dieser Konstruktoren mit identischen Byte Arrays Zeichen folgen erstellt werden, die unterschiedliche Werte für verschiedene Systeme 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.

Behandeln wiederholter Zeichen folgenHandling repetitive strings

Apps, die Text Ströme analysieren oder decodieren, verwenden häufig den String(Char[], Int32, Int32) -Konstruktor oder StringBuilder.Append(Char[], Int32, Int32) die-Methode, um Zeichen folgen 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. Wiederholtes Erstellen neuer Zeichen folgen mit demselben Wert, anstatt eine Zeichenfolge zu erstellen und wieder zu verwenden, verschwendet Arbeitsspeicher.Repeatedly creating new strings with the same value instead of creating and reusing one string wastes memory. Wenn Sie wahrscheinlich den gleichen Zeichen folgen Wert wiederholt durch Aufrufen des String(Char[], Int32, Int32) Konstruktors erstellen, können Sie stattdessen eine Nachschlage Tabelle verwenden, auch wenn Sie nicht im Voraus wissen, welche identischen Zeichen folgen Werte Sie verwenden können.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.

Angenommen, Sie lesen und analysieren einen Datenstrom 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 analysieren, stoßen Sie wiederholt auf bestimmte Token (d. h. Zeichen folgen, 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 den Zeichen folgen "0", "1", "true" und "false" entsprechen, treten wahrscheinlich häufig in einem XML-Stream auf.Tokens equivalent to the strings "0", "1", "true", and "false" are likely to occur frequently in an XML stream.

Anstatt jedes Token in eine neue Zeichenfolge zu wandeln, können Sie ein System.Xml.NameTable -Objekt erstellen, um häufig auftretende Zeichen folgen zu speichern.Instead of converting each token into a new string, you can create a System.Xml.NameTable object to hold commonly occurring strings. Das NameTable -Objekt verbessert die Leistung, da gespeicherte Zeichen folgen abgerufen werden, ohne temporären Arbeitsspeicher zuzuordnen.The NameTable object improves performance, because it retrieves stored strings without allocating temporary memory. Wenn Sie ein Token finden, verwenden Sie NameTable.Get(Char[], Int32, Int32) die-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 NameTable.Add(Char[], Int32, Int32) die-Methode, um das Token in die Tabelle einzufügen und die entsprechende Zeichenfolge zu erhalten.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: Verwenden der Zeichen folgen ZuweisungExample 1: Using string assignment

Im folgenden Beispiel wird eine neue Zeichenfolge durch Zuweisen eines Zeichenfolgenliterals erstellt.The following example creates a new string by assigning it a string literal. Es wird eine zweite Zeichenfolge erstellt, indem der Wert der ersten Zeichenfolge zugewiesen wird.It creates a second string by assigning the value of the first string to it. Dies sind die beiden gängigsten Methoden, um ein neues String -Objekt zu instanziieren.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 eines Zeichen ArraysExample 2: Using a character array

Im folgenden Beispiel wird veranschaulicht, wie ein neues String -Objekt aus einem Zeichen Array erstellt wird.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 eines Teils eines Zeichen Arrays und Wiederholen eines einzelnen ZeichensExample 3: Using a portion of a character array and repeating a single character

Im folgenden Beispiel wird veranschaulicht, wie ein neues String -Objekt aus einem Teil eines Zeichen Arrays erstellt wird und wie ein neues String -Objekt erstellt wird, 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: Verwenden eines Zeigers auf ein Zeichen ArrayExample 4: Using a pointer to a character array

Im folgenden Beispiel wird veranschaulicht, wie ein neues String -Objekt aus einem Zeiger auf ein Zeichen Array erstellt wird.The following example demonstrates how to create a new String object from a pointer to an array of characters. Das C# Beispiel muss mithilfe des /unsafe -Compilerschalters kompiliert werden.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 einer Zeichenfolge aus einem Zeiger und einem Bereich eines ArraysExample 5: Instantiating a string from a pointer and a range of an array

Im folgenden Beispiel werden die Elemente eines Zeichen Arrays für einen Punkt oder ein Ausrufezeichen untersucht.The following example examines the elements of a character array for either a period or an exclamation point. Wenn eine Zeichenfolge gefunden wird, wird eine Zeichenfolge aus den Zeichen im Array instanziiert, die dem Interpunktions Zeichen vorangestellt ist.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 eine Zeichenfolge mit dem gesamten Inhalt des Arrays instanziiert.If not, it instantiates a string with the entire contents of the array. Das C# Beispiel muss mithilfe des /unsafe -Compilerschalters kompiliert werden.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 einer Zeichenfolge von einem Zeiger auf ein Bytearray mit VorzeichenExample 6: Instantiating a string from a pointer to a signed byte array

Im folgenden Beispiel wird veranschaulicht, wie Sie eine Instanz der String -Klasse mit dem String(SByte*) -Konstruktor erstellen können.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 über Ladungen werden in 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 über Ladungen werden in unterstützt: 4, 3,5 SP1All overloads are supported in: 4, 3.5 SP1

Portable KlassenbibliothekPortable Class Library
Alle über Ladungen ohne 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 über Ladungen ohne SByte * -Parameter werden in 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 umfassende Verwendungs Informationen zu dieser und anderen String Konstruktorüberladungen finden Sie in der Zusammenfassung des String Konstruktors.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 umfassende Verwendungs Informationen zu dieser und anderen String Konstruktorüberladungen finden Sie in der Zusammenfassung des String Konstruktors.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 umfassende Verwendungs Informationen zu dieser und anderen String Konstruktorüberladungen finden Sie in der Zusammenfassung des String Konstruktors.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 umfassende Verwendungs Informationen zu dieser und anderen String Konstruktorüberladungen finden Sie in der Zusammenfassung des String Konstruktors.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 umfassende Verwendungs Informationen zu dieser und anderen String Konstruktorüberladungen finden Sie in der Zusammenfassung des String Konstruktors.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 umfassende Verwendungs Informationen zu dieser und anderen String Konstruktorüberladungen finden Sie in der Zusammenfassung des String Konstruktors.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 umfassende Verwendungs Informationen zu dieser und anderen String Konstruktorüberladungen finden Sie in der Zusammenfassung des String Konstruktors.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 umfassende Verwendungs Informationen zu dieser und anderen String Konstruktorüberladungen finden Sie in der Zusammenfassung des String Konstruktors.For examples and comprehensive usage information about this and other String constructor overloads, see the String constructor summary.

Gilt für: