System.String-Konstruktor

Artikel
01/30/2024

Dieser Artikel enthält ergänzende Hinweise zur Referenzdokumentation für diese API.

Syntax des überladenen Konstruktors

Zeichenfolgenkonstruktoren sind in zwei Kategorien unterteilt: diejenigen ohne Zeigerparameter und solche mit Zeigerparametern. Die Konstruktoren, die Zeiger verwenden, sind nicht CLS-kompatibel. Darüber hinaus unterstützt Visual Basic die Verwendung von Zeigern nicht, und C# erfordert Code, der Zeiger zum Ausführen in einem unsicheren Kontext verwendet. Weitere Informationen finden Sie unter unsafe.

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

String(Char[] value)
Initialisiert die neue Instanz auf den Wert, der durch ein Array von Unicode-Zeichen angegeben wird. Dieser Konstruktor kopiert Unicode-Zeichen(Beispiel 2: Verwenden eines Zeichenarrays).

String(Char[] value, Int32 startIndex, Int32 length)
Initialisiert die neue Instanz auf den Wert, der durch ein Array von Unicode-Zeichen, eine Anfangszeichenposition innerhalb dieses Arrays und eine Länge angegeben wird (Beispiel 3: Verwenden eines Teils eines Zeichenarrays und Wiederholen eines einzelnen Zeichens).

String(Char c, Int32 count)
Initialisiert die neue Instanz auf den Wert, der durch ein angegebenes Unicode-Zeichen angegeben wird, wiederholt eine bestimmte Anzahl von Malen (Beispiel 3: Verwenden eines Teils eines Zeichenarrays und Wiederholen eines einzelnen Zeichens).

String(char* value)
(Nicht CLS-kompatibel) Initialisiert die neue Instanz auf den Wert, der durch einen Zeiger auf ein Array von Unicode-Zeichen angegeben wird, das durch ein Nullzeichen (U+0000 oder '\0' beendet wird). (Beispiel 4: Verwenden eines Zeigers auf ein Zeichenarray).

Berechtigung: SecurityCriticalAttribute, erfordert volle Vertrauensstellung für den unmittelbaren Anrufer. Dieses Element kann nicht von teilweise vertrauenswürdigem oder transparentem Code verwendet werden.

String(char* value, Int32 startIndex, Int32 length)
(Nicht CLS-kompatibel) Initialisiert die neue Instanz auf den Von einem Zeiger angegebenen Wert auf ein Array von Unicode-Zeichen, eine Anfangszeichenposition innerhalb dieses Arrays und eine Länge. Der Konstruktor kopiert die Unicode-Zeichen beginnend am Index und endet am Index + startIndexlength - 1 (Beispiel 5: Instanziieren einer Zeichenfolge von einem Zeiger und einem Bereich eines Arrays).startIndex value

String(SByte* value)
(Nicht CLS-kompatibel) Initialisiert die neue Instanz auf den Wert, der durch einen Zeiger auf ein Array mit 8-Bit-ganzzahlen angegeben ist. Das Array wird angenommen, um eine Zeichenfolge darzustellen, die mit der aktuellen Systemcodeseite codiert ist (d. a. die durch Encoding.Default). Der Konstruktor verarbeitet Zeichen von value der Vom Zeiger angegebenen Position, bis ein NULL-Zeichen (0x00) erreicht ist (Beispiel 6: Instanziieren einer Zeichenfolge von einem Zeiger auf ein signiertes Bytearray).

String(SByte* value, Int32 startIndex, Int32 length)
(Nicht CLS-kompatibel) Initialisiert die neue Instanz auf den Wert, der von einem Zeiger auf ein Array mit 8-Bit-ganzzahlen, einer Anfangsposition innerhalb dieses Arrays und einer Länge angegeben wird. Das Array wird angenommen, um eine Zeichenfolge darzustellen, die mit der aktuellen Systemcodeseite codiert ist (d. a. die durch Encoding.Default). Der Konstruktor verarbeitet Zeichen vom Wert ab und startIndex endet mit startIndex + length - 1 (Beispiel 6: Instanziieren einer Zeichenfolge von einem Zeiger auf ein signiertes Bytearray).

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

Parameter

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

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

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

Parameter	Typ	Beschreibung
`value`	Char* Oder SByte*	Ein Zeiger auf ein mit Null beendetes Array von Unicode-Zeichen oder ein Array mit 8-Bit-Ganzzahlen. Wenn `value` es sich um ein leeres Array handelt `null` , lautet String.Emptyder Wert der neuen Zeichenfolge .
`startIndex`	Int32	Der Index des Arrayelements, das das erste Zeichen in der neuen Zeichenfolge definiert. Standardwert: 0
`length`	Int32	Die Anzahl der Arrayelemente, die zum Erstellen der neuen Zeichenfolge verwendet werden sollen. Wenn die Länge null ist, erstellt der Konstruktor eine Zeichenfolge, deren Wert lautet String.Empty. Standardwert: Array.Length
`enc`	Encoding	Ein Objekt, das angibt, wie das `value` Array codiert wird. Standardwert: Encoding.Defaultoder die aktuelle ANSI-Codeseite des Systems

Ausnahmen

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

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

Hier ist eine Liste von Ausnahmen, die von Konstruktoren ausgelöst werden, die Zeigerparameter enthalten.

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

Welche Methode wird aufgerufen?

Beschreibung	Anrufen oder Verwenden
Erstellen Sie eine Zeichenfolge.	Zuweisung aus einem Zeichenfolgenliteral oder einer vorhandenen Zeichenfolge (Beispiel 1: Zeichenfolgenzuweisung verwenden)
Erstellen Sie eine Zeichenfolge aus einem gesamten Zeichenarray.	String(Char[]) (Beispiel 2: Verwenden eines Zeichenarrays)
Erstellen Sie eine Zeichenfolge aus einem Teil eines Zeichenarrays.	String(Char[], Int32, Int32) (Beispiel 3: Verwenden eines Teils eines Zeichenarrays und Wiederholen eines einzelnen Zeichens)
Erstellen Sie eine Zeichenfolge, die dasselbe Zeichen mehrmals wiederholt.	String(Char, Int32) (Beispiel 3: Verwenden eines Teils eines Zeichenarrays und Wiederholen eines einzelnen Zeichens)
Erstellen Sie eine Zeichenfolge von einem Zeiger auf ein Unicode- oder breites Zeichenarray.	String(Char*)
Erstellen Sie eine Zeichenfolge aus einem Teil eines Unicode- oder breiten Zeichenarrays mithilfe des Zeigers.	String(Char*, Int32, Int32)
Erstellen Sie eine Zeichenfolge aus einem C++ `char` -Array.	String(SByte), String(SByte, Int32, Int32) Oder String(SByte*, Int32, Int32, Encoding)
Erstellen Sie eine Zeichenfolge aus ASCII-Zeichen.	ASCIIEncoding.GetString

Erstellen von Zeichenfolgen

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

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

Wenn Ihr Code Zeichenfolgen mit demselben Wert wiederholt instanziiert, können Sie die Anwendungsleistung mithilfe einer alternativen Möglichkeit zum Erstellen von Zeichenfolgen verbessern. Weitere Informationen finden Sie unter Behandeln sich wiederholender Zeichenfolgen.
Aus einem einzelnen Zeichen, das mit dem String(Char, Int32) Konstruktor dupliziert wird, wird ein oder mehrere Male dupliziert. Wenn count null ist, lautet String.Emptyder Wert der neuen Zeichenfolge .
Von einem Zeiger auf ein durch Null beendetes Zeichenarray mithilfe des oder String(Char*, Int32, Int32) des String(Char*) Konstruktors. Entweder das gesamte Array oder ein angegebener Bereich kann zum Initialisieren der Zeichenfolge verwendet werden. Der Konstruktor kopiert eine Abfolge von Unicode-Zeichen beginnend mit dem angegebenen Zeiger oder vom angegebenen Zeiger plus startIndex und fortgesetzt bis zum Ende des Arrays oder für length Zeichen. Wenn value es sich um einen Nullzeiger handelt oder length null ist, erstellt der Konstruktor eine Zeichenfolge, deren Wert lautet String.Empty. Wenn der Kopiervorgang am Ende des Arrays fortgesetzt wird und das Array nicht null beendet ist, ist das Konstruktorverhalten systemabhängig. Eine solche Bedingung kann zu einer Zugriffsverletzung führen.

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

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

      foreach (var ch in s)
         Console.Write($"{(ushort)ch:X4} ");
      Console.WriteLine();
      
      fixed(char* chPtr = chars) {
         s = new string(chPtr);         
      }
      
      foreach (var ch in s)
         Console.Write($"{(ushort)ch:X4} ");
      Console.WriteLine();    
   }
}
// The example displays the following output:
//       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
//       0061 0062 0063 0064
```
```
#nowarn "9"
open System

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

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

let s2 = 
    use chPtr = fixed chars
    String chPtr    

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

Wenn die String(Char*) Überladung aufgerufen wird und das Array nicht null beendet wird, oder wenn die String(Char*, Int32, Int32) Überladung aufgerufen wird und startIndex + length-1 einen Bereich enthält, der außerhalb des für die Abfolge von Zeichen zugewiesenen Speichers liegt, ist das Verhalten des Konstruktors systemabhängig, und eine Zugriffsverletzung kann auftreten.
Von einem Zeiger auf ein signiertes Bytearray. Entweder das gesamte Array oder ein angegebener Bereich kann zum Initialisieren der Zeichenfolge verwendet werden. Die Bytesequenz kann mithilfe der Standardcodeseitencodierung interpretiert werden, oder eine Codierung kann im Konstruktoraufruf angegeben werden. Wenn der Konstruktor versucht, eine Zeichenfolge aus einem gesamten Array zu instanziieren, das nicht null beendet ist, oder wenn der Bereich des Arrays von value + startIndex - + value + startIndexlength1 außerhalb des für das Array zugewiesenen Speichers liegt, ist das Verhalten dieses Konstruktors systemabhängig, und es kann zu einer Zugriffsverletzung kommen.

Die drei Konstruktoren, die ein signiertes Bytearray als Parameter enthalten, sind in erster Linie für die Konvertierung eines C++ char -Arrays in eine Zeichenfolge konzipiert, wie in diesem Beispiel gezeigt:
```
using namespace System;

void main()
{
      char chars[] = { 'a', 'b', 'c', 'd', '\x00' };
      
      char* charPtr = chars;
      String^ value = gcnew String(charPtr);

      Console::WriteLine(value);
}
// The example displays the following output:
//      abcd
```
Wenn das Array Nullzeichen ('\0') oder Byte enthält, deren Wert 0 ist und die String(SByte*, Int32, Int32) Überladung aufgerufen wird, enthält length die Zeichenfolgeninstanz Zeichen einschließlich eingebetteter Nullen. Das folgende Beispiel zeigt, was passiert, wenn ein Zeiger auf ein Array von 10 Elementen mit zwei NULL-Zeichen an die String(SByte*, Int32, Int32) Methode übergeben wird. Da die Adresse der Anfang des Arrays ist und alle Elemente im Array der Zeichenfolge hinzugefügt werden sollen, instanziiert der Konstruktor eine Zeichenfolge mit zehn Zeichen, einschließlich zwei eingebetteter Nullen. Wenn dasselbe Array hingegen an den Konstruktor übergeben wird, handelt es sich bei dem String(SByte*) Ergebnis um eine vierstellige Zeichenfolge, die das erste Nullzeichen nicht enthält.
```
using System;

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

      fixed(sbyte* bytePtr = bytes) {
         s = new string(bytePtr);         
      }
      
      foreach (var ch in s)
         Console.Write($"{(ushort)ch:X4} ");
      Console.WriteLine();    
   }
}
// The example displays the following output:
//       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
//       0061 0062 0063 0064
```
```
#nowarn "9"
open System

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

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

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

let s2 =
    use bytePtr = fixed bytes
    String bytePtr         

for ch in s do
    printf $"{uint16 ch:X4} "
printfn ""
// The example displays the following output:
//       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
//       0061 0062 0063 0064
```
Da die String(SByte*) String(SByte*, Int32, Int32) Konstruktoren mithilfe der STANDARDMÄßIGen ANSI-Codeseite interpretiert werden value , können beim Aufrufen dieser Konstruktoren mit identischen Bytearrays Zeichenfolgen mit unterschiedlichen Werten auf verschiedenen Systemen erstellt werden.

Behandeln von sich wiederholenden Zeichenfolgen

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

Angenommen, Sie lesen und analysieren einen Datenstrom von Zeichen aus einer Datei, die XML-Tags und Attribute enthält. Wenn Sie den Datenstrom analysieren, werden wiederholt bestimmte Token (d. h. Abfolgen von Zeichen, die eine symbolische Bedeutung haben) gefunden. Token, die den Zeichenfolgen "0", "1", "true" und "false" entsprechen, treten wahrscheinlich häufig in einem XML-Datenstrom auf.

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

Beispiel 1: Verwenden der Zeichenfolgenzuweisung

Im folgenden Beispiel wird eine neue Zeichenfolge erstellt, indem sie ihm ein Zeichenfolgenliteral zuweist. Sie erstellt eine zweite Zeichenfolge, indem Sie ihm den Wert der ersten Zeichenfolge zuweisen. Dies sind die beiden am häufigsten verwendeten Methoden zum Instanziieren eines neuen String Objekts.

using System;

public class Example3
{
   public static void Main()
   {
      String value1 = "This is a string.";
      String value2 = value1;
      Console.WriteLine(value1);
      Console.WriteLine(value2);
   }
}
// The example displays the following output:
//    This is a string.
//    This is a string.

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

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

Beispiel 2: Verwenden eines Zeichenarrays

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

// Unicode Mathematical operators
char [] charArr1 = {'\u2200','\u2202','\u200F','\u2205'};
String szMathSymbols = new String(charArr1);

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

// Compare Strings - the result is false
Console.WriteLine("The Strings are equal? " +
    (String.Compare(szMathSymbols, szLetterLike)==0?"true":"false") );

// Unicode Mathematical operators
let charArr1 = [| '\u2200'; '\u2202'; '\u200F'; '\u2205' |]
let szMathSymbols = String charArr1

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

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

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

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

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

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

Im folgenden Beispiel wird das Erstellen eines neuen String Objekts aus einem Teil eines Zeichenarrays und das Erstellen eines neuen String Objekts veranschaulicht, das mehrere Vorkommen eines einzelnen Zeichens enthält.

// Create a Unicode String with 5 Greek Alpha characters
String szGreekAlpha = new String('\u0391',5);
// Create a Unicode String with a Greek Omega character
String szGreekOmega = new String(new char [] {'\u03A9','\u03A9','\u03A9'},2,1);

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

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

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

Console.WriteLine("The Greek letter Alpha first appears at index " + ialpha +
    " and Omega last appears at index " + iomega + " in this String.");

// Create a Unicode String with 5 Greek Alpha characters
let szGreekAlpha = String('\u0391',5)
// Create a Unicode String with a Greek Omega character
let szGreekOmega = String([| '\u03A9'; '\u03A9'; '\u03A9' |],2,1)

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

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

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

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

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

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

' Examine the result
Console.WriteLine(szGreekLetters)

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

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

Beispiel 4: Verwenden eines Zeigers auf ein Zeichenarray

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

using System;

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

#nowarn "9"
open System

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

let value =
    use charPtr = fixed characters
    String charPtr

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

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

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

using System;

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

#nowarn "9"
open System
open FSharp.NativeInterop

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

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

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

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

unsafe
{
    // Null terminated ASCII characters in an sbyte array
    String szAsciiUpper = null;
    sbyte[] sbArr1 = new sbyte[] { 0x41, 0x42, 0x43, 0x00 };
    // Instruct the Garbage Collector not to move the memory
    fixed(sbyte* pAsciiUpper = sbArr1)
    {
        szAsciiUpper = new String(pAsciiUpper);
    }
    String szAsciiLower = null;
    sbyte[] sbArr2 = { 0x61, 0x62, 0x63, 0x00 };
    // Instruct the Garbage Collector not to move the memory
    fixed(sbyte* pAsciiLower = sbArr2)
    {
        szAsciiLower = new String(pAsciiLower, 0, sbArr2.Length);
    }
    // Prints "ABC abc"
    Console.WriteLine(szAsciiUpper + " " + szAsciiLower);

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

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

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

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

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

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

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

Freigeben über