Konstruktor System.String

Artykuł
01/30/2024

Ten artykuł zawiera dodatkowe uwagi dotyczące dokumentacji referencyjnej dla tego interfejsu API.

Przeciążona składnia konstruktora

Konstruktory ciągów dzielą się na dwie kategorie: te bez parametrów wskaźnika i te z parametrami wskaźnika. Konstruktory używające wskaźników nie są zgodne ze specyfikacją CLS. Ponadto język Visual Basic nie obsługuje używania wskaźników, a język C# wymaga kodu, który używa wskaźników do uruchamiania w niebezpiecznym kontekście. Aby uzyskać więcej informacji, zobacz niebezpieczne.

Aby uzyskać dodatkowe wskazówki dotyczące wybierania przeciążenia, zobacz Którą metodę wywołam?.

String(Char[] value)
Inicjuje nowe wystąpienie do wartości wskazanej przez tablicę znaków Unicode. Ten konstruktor kopiuje znaki Unicode (Przykład 2: Użyj tablicy znaków).

String(Char[] value, Int32 startIndex, Int32 length)
Inicjuje nowe wystąpienie do wartości wskazanej przez tablicę znaków Unicode, pozycję początkowego znaku w tej tablicy i długość (przykład 3: Użyj części tablicy znaków i powtórzenia pojedynczego znaku).

String(Char c, Int32 count)
Inicjuje nowe wystąpienie do wartości wskazanej przez określony znak Unicode powtórzony określoną liczbę razy (przykład 3: Użyj części tablicy znaków i powtórzenia pojedynczego znaku).

String(char* value)
(Niezgodne ze specyfikacją CLS) Inicjuje nowe wystąpienie do wartości wskazanej przez wskaźnik do tablicy znaków Unicode zakończonych znakiem null (U+0000 lub \0). (Przykład 4: Użyj wskaźnika do tablicy znaków).

Uprawnienie: SecurityCriticalAttribute, wymaga pełnego zaufania dla bezpośredniego obiektu wywołującego. Ten element członkowski nie może być używany przez częściowo zaufany lub przejrzysty kod.

String(char* value, Int32 startIndex, Int32 length)
(Niezgodne ze specyfikacją CLS) Inicjuje nowe wystąpienie do wartości wskazanej przez wskaźnik do tablicy znaków Unicode, pozycji znaku początkowego w tej tablicy i długości. Konstruktor kopiuje znaki Unicode od value początku indeksu i kończąc na indeksie + startIndexlengthstartIndex — 1 (przykład 5: Utworzenie wystąpienia ciągu ze wskaźnika i zakresu tablicy).

String(SByte* value)
(Niezgodne ze specyfikacją CLS) Inicjuje nowe wystąpienie do wartości wskazanej przez wskaźnik do tablicy 8-bitowych liczb całkowitych ze znakiem. Przyjmuje się, że tablica reprezentuje ciąg zakodowany przy użyciu bieżącej strony kodowej systemu (czyli kodowania określonego przez Encoding.Defaultmetodę ). Konstruktor przetwarza znaki rozpoczynające się od value lokalizacji określonej przez wskaźnik do momentu osiągnięcia znaku null (0x00) (przykład 6: utworzenie wystąpienia ciągu ze wskaźnika do podpisanej tablicy bajtów).

String(SByte* value, Int32 startIndex, Int32 length)
(Niezgodne ze specyfikacją CLS) Inicjuje nowe wystąpienie do wartości wskazanej przez wskaźnik do tablicy 8-bitowych liczb całkowitych ze znakiem, pozycji początkowej w tej tablicy i długości. Przyjmuje się, że tablica reprezentuje ciąg zakodowany przy użyciu bieżącej strony kodowej systemu (czyli kodowania określonego przez Encoding.Defaultmetodę ). Konstruktor przetwarza znaki z wartości rozpoczynającej się od i kończącej się na startIndexstartIndexlength + - 1 (Przykład 6: Utworzenie wystąpienia ciągu ze wskaźnika do podpisanej tablicy bajtów).

String(SByte* value, Int32 startIndex, Int32 length, Encoding enc)
(Niezgodne ze specyfikacją CLS) Inicjuje nowe wystąpienie do wartości wskazanej przez wskaźnik do tablicy 8-bitowych liczb całkowitych ze znakiem, pozycji początkowej w tej tablicy, długości i Encoding obiektu.

Parametry

Oto pełna lista parametrów używanych przez String konstruktory, które nie zawierają parametru wskaźnika. Dla parametrów używanych przez każde przeciążenie, zobacz powyżej temat dotyczący składni przeciążenia.

Parametr	Type	Opis
`value`	Char[]	Tablica znaków Unicode.
`c`	Char	Znak Unicode.
`startIndex`	Int32	Pozycja początkowa pierwszego `value` znaku w nowym ciągu. Wartość domyślna: 0
`length`	Int32	Liczba znaków do `value` uwzględnienia w nowym ciągu. Wartość domyślna: Array.Length
`count`	Int32	Liczba powtórzeń znaku `c` w nowym ciągu. Jeśli `count` ma wartość zero, wartość nowego obiektu to String.Empty.

Oto pełna lista parametrów używanych przez String konstruktory, które zawierają parametr wskaźnika. Dla parametrów używanych przez każde przeciążenie, zobacz powyżej temat dotyczący składni przeciążenia.

Parametr	Type	Opis
`value`	Char* — lub — SByte*	Wskaźnik do tablicy znaków Unicode zakończonych wartościami null lub tablicy z 8-bitowymi liczbami całkowitymi ze znakiem. Jeśli `value` jest `null` lub pusta tablica, wartość nowego ciągu to String.Empty.
`startIndex`	Int32	Indeks elementu tablicy, który definiuje pierwszy znak w nowym ciągu. Wartość domyślna: 0
`length`	Int32	Liczba elementów tablicy używanych do utworzenia nowego ciągu. Jeśli długość wynosi zero, konstruktor tworzy ciąg, którego wartość to String.Empty. Wartość domyślna: Array.Length
`enc`	Encoding	Obiekt określający sposób kodowania tablicy `value` . Wartość domyślna: Encoding.Defaultlub bieżąca strona kodowa ANSI systemu

Wyjątki

Oto lista wyjątków zgłaszanych przez konstruktory, które nie zawierają parametrów wskaźnika.

Wyjątek	Stan	Generowane przez
ArgumentNullException	Parametr `value` ma wartość `null`.	String(Char[], Int32, Int32)
ArgumentOutOfRangeException	`startIndex`,`length` lub `count` jest mniejszy niż zero. — lub — Suma wartości `startIndex` i `length` jest większa niż liczba elementów w elem `value`. — lub — Parametr `count` ma wartość niższą niż zero.	String(Char, Int32) String(Char[], Int32, Int32)

Oto lista wyjątków zgłaszanych przez konstruktory, które zawierają parametry wskaźnika.

Wyjątek	Stan	Generowane przez
ArgumentException	`value` określa tablicę zawierającą nieprawidłowy znak Unicode. — lub — `value` lub `value` + `startIndex` określa adres, który jest mniejszy niż 64K. — lub — Nie można zainicjować nowego String wystąpienia z tablicy bajtów, `value` ponieważ `value` nie używa domyślnego kodowania strony kodowej.	Wszystkie konstruktory ze wskazówkami.
ArgumentNullException	`value` ma wartość null.	String(SByte) String(SByte, Int32, Int32) String(SByte*, Int32, Int32, Encoding)
ArgumentOutOfRangeException	Bieżący proces nie ma dostępu do odczytu do wszystkich adresowanych znaków. — lub — `startIndex` lub `length` jest mniejsza niż zero, `value` + `startIndex` powoduje przepełnienie wskaźnika lub bieżący proces nie ma dostępu do odczytu do wszystkich adresowanych znaków. — lub — Długość nowego ciągu jest zbyt duża, aby przydzielić.	Wszystkie konstruktory ze wskazówkami.
AccessViolationException	`value`, lub `value` + + `startIndexlength` - 1, określa nieprawidłowy adres.	String(SByte) String(SByte, Int32, Int32) String(SByte*, Int32, Int32, Encoding)

Jaką metodę wywołać?

To	Wywoływanie lub używanie
Utwórz ciąg.	Przypisanie z literału ciągu lub istniejącego ciągu (przykład 1: użyj przypisania ciągu)
Utwórz ciąg na podstawie całej tablicy znaków.	String(Char[]) (Przykład 2: Używanie tablicy znaków)
Utwórz ciąg na podstawie części tablicy znaków.	String(Char[], Int32, Int32) (Przykład 3: Użyj części tablicy znaków i powtórzenia pojedynczego znaku)
Utwórz ciąg, który powtarza ten sam znak wiele razy.	String(Char, Int32) (Przykład 3: Użyj części tablicy znaków i powtórzenia pojedynczego znaku)
Utwórz ciąg ze wskaźnika do tablicy znaków Unicode lub szerokiej.	String(Char*)
Utwórz ciąg na podstawie części tablicy znaków Unicode lub szerokiej za pomocą wskaźnika.	String(Char*, Int32, Int32)
Utwórz ciąg na podstawie tablicy języka C++ `char` .	String(SByte), String(SByte, Int32, Int32) — lub — String(SByte*, Int32, Int32, Encoding)
Utwórz ciąg na podstawie znaków ASCII.	ASCIIEncoding.GetString

Tworzenie ciągów

Najczęściej używaną techniką tworzenia ciągów programowo jest proste przypisanie, jak pokazano w przykładzie 1. Klasa String zawiera również cztery typy przeciążeń konstruktora, które umożliwiają tworzenie ciągów na podstawie następujących wartości:

Z tablicy znaków (tablica znaków zakodowanych w formacie UTF-16). Możesz utworzyć nowy String obiekt na podstawie znaków w całej tablicy lub części. Konstruktor String(Char[]) kopiuje wszystkie znaki w tablicy do nowego ciągu. Konstruktor String(Char[], Int32, Int32) kopiuje znaki z indeksu do indeksu startIndexstartIndex + length — 1 do nowego ciągu. Jeśli length ma wartość zero, wartość nowego ciągu to String.Empty.

Jeśli kod wielokrotnie tworzy wystąpienia ciągów o tej samej wartości, możesz zwiększyć wydajność aplikacji przy użyciu alternatywnych metod tworzenia ciągów. Aby uzyskać więcej informacji, zobacz Obsługa powtarzających się ciągów.
Z pojedynczego znaku, który jest zduplikowany zero, jeden lub więcej razy, przy użyciu konstruktora String(Char, Int32) . Jeśli count ma wartość zero, wartość nowego ciągu to String.Empty.
Od wskaźnika do tablicy znaków zakończonej wartością null przy użyciu konstruktora String(Char*) lub String(Char*, Int32, Int32) . Do zainicjowania ciągu można wykorzystać macierz w całości lub w określonym zakresie. Konstruktor kopiuje sekwencję znaków Unicode rozpoczynających się od określonego wskaźnika lub od określonego wskaźnika plus startIndex i kontynuując do końca tablicy lub znaków length . Jeśli value jest wskaźnikiem o wartości null lub length ma wartość zero, konstruktor tworzy ciąg, którego wartość to String.Empty. Jeśli operacja kopiowania następuje na końcu tablicy, a tablica nie kończy się wartością null, zachowanie konstruktora jest zależne od systemu. Taki warunek może spowodować naruszenie dostępu.

Jeśli tablica zawiera jakiekolwiek osadzone znaki null (U+0000 lub "\0"), a String(Char*, Int32, Int32) przeciążenie jest wywoływane, wystąpienie ciągu zawiera length znaki, w tym wszelkie osadzone wartości null. W poniższym przykładzie pokazano, co się stanie, gdy wskaźnik do tablicy 10 elementów zawierających dwa znaki null jest przekazywany do String(Char*, Int32, Int32) metody . Ponieważ adres jest początkiem tablicy, a wszystkie elementy tablicy mają zostać dodane do ciągu, konstruktor tworzy wystąpienie ciągu z dziesięcioma znakami, w tym dwie osadzone wartości null. Z drugiej strony, jeśli ta sama tablica jest przekazywana do String(Char*) konstruktora, wynik jest czteroznacznym ciągiem, który nie zawiera pierwszego znaku null.
```
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
```
Tablica musi zawierać znaki Unicode. W języku C++oznacza to, że tablica znaków musi być zdefiniowana jako Charzarządzany typ [] lub typ niezarządzanywchar_t[].

String(Char*) Jeśli przeciążenie jest wywoływane, a tablica nie kończy się wartością null lub jeśli String(Char*, Int32, Int32) przeciążenie jest wywoływane startIndex + lengthi -1 zawiera zakres, który znajduje się poza pamięcią przydzieloną dla sekwencji znaków, zachowanie konstruktora jest zależne od systemu, a może wystąpić naruszenie dostępu.
Od wskaźnika do podpisanej tablicy bajtów. Do zainicjowania ciągu można wykorzystać macierz w całości lub w określonym zakresie. Sekwencję bajtów można interpretować przy użyciu domyślnego kodowania strony kodowej lub kodowanie można określić w wywołaniu konstruktora. Jeśli konstruktor próbuje utworzyć wystąpienie ciągu z całej tablicy, która nie jest zakończona wartością null, lub jeśli zakres tablicy z value + startIndex do + value + startIndexlength -1 znajduje się poza pamięcią przydzieloną dla tablicy, zachowanie tego konstruktora jest zależne od systemu, a może wystąpić naruszenie dostępu.

Trzy konstruktory, które zawierają podpisaną tablicę bajtów jako parametr, są przeznaczone głównie do konwertowania tablicy C++ char na ciąg, jak pokazano w tym przykładzie:
```
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
```
Jeśli tablica zawiera jakiekolwiek znaki null ('\0') lub bajty, których wartość wynosi 0, a String(SByte*, Int32, Int32) przeciążenie jest wywoływane, wystąpienie ciągu zawiera length znaki, w tym wszelkie osadzone wartości null. W poniższym przykładzie pokazano, co się stanie, gdy wskaźnik do tablicy 10 elementów zawierających dwa znaki null jest przekazywany do String(SByte*, Int32, Int32) metody . Ponieważ adres jest początkiem tablicy, a wszystkie elementy tablicy mają zostać dodane do ciągu, konstruktor tworzy wystąpienie ciągu z dziesięcioma znakami, w tym dwie osadzone wartości null. Z drugiej strony, jeśli ta sama tablica jest przekazywana do String(SByte*) konstruktora, wynik jest czteroznacznym ciągiem, który nie zawiera pierwszego znaku null.
```
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
```
String(SByte*) Ponieważ konstruktory i String(SByte*, Int32, Int32) interpretują value przy użyciu domyślnej strony kodowej ANSI, wywoływanie tych konstruktorów z identycznymi tablicami bajtów może tworzyć ciągi, które mają różne wartości w różnych systemach.

Obsługa powtarzających się ciągów

Aplikacje, które analizują lub dekodują strumienie tekstu, często używają String(Char[], Int32, Int32) konstruktora lub StringBuilder.Append(Char[], Int32, Int32) metody do konwertowania sekwencji znaków na ciąg. Wielokrotnie tworzysz nowe ciągi o tej samej wartości zamiast tworzyć i ponownie korzystać z pamięci jednego ciągu. Jeśli prawdopodobnie wielokrotnie tworzysz tę samą wartość ciągu, wywołując String(Char[], Int32, Int32) konstruktora, nawet jeśli nie wiesz wcześniej, jakie mogą być te identyczne wartości ciągów, możesz zamiast tego użyć tabeli odnośników.

Załóżmy na przykład, że odczytujesz i przeanalizujesz strumień znaków z pliku zawierającego tagi i atrybuty XML. Podczas analizowania strumienia wielokrotnie napotykasz pewne tokeny (czyli sekwencje znaków, które mają znaczenie symboliczne). Tokeny równoważne ciągom "0", "1", "true" i "false" prawdopodobnie występują często w strumieniu XML.

Zamiast konwertować każdy token na nowy ciąg, można utworzyć System.Xml.NameTable obiekt do przechowywania często występujących ciągów. Obiekt NameTable poprawia wydajność, ponieważ pobiera przechowywane ciągi bez przydzielania pamięci tymczasowej. W przypadku napotkania tokenu NameTable.Get(Char[], Int32, Int32) użyj metody , aby pobrać token z tabeli. Jeśli token istnieje, metoda zwraca odpowiedni ciąg. Jeśli token nie istnieje, użyj NameTable.Add(Char[], Int32, Int32) metody , aby wstawić token do tabeli i uzyskać odpowiedni ciąg.

Przykład 1. Używanie przypisania ciągu

Poniższy przykład tworzy nowy ciąg, przypisując mu literał ciągu. Tworzy drugi ciąg, przypisując do niego wartość pierwszego ciągu. Są to dwa najbardziej typowe sposoby tworzenia wystąpienia nowego String obiektu.

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.

Przykład 2. Używanie tablicy znaków

W poniższym przykładzie pokazano, jak utworzyć nowy String obiekt na podstawie tablicy znaków.

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

Przykład 3. Używanie części tablicy znaków i powtarzanie pojedynczego znaku

W poniższym przykładzie pokazano, jak utworzyć nowy String obiekt na podstawie części tablicy znaków oraz jak utworzyć nowy String obiekt zawierający wiele wystąpień pojedynczego znaku.

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

Przykład 4. Używanie wskaźnika do tablicy znaków

W poniższym przykładzie pokazano, jak utworzyć nowy String obiekt ze wskaźnika do tablicy znaków. Przykład języka C# należy skompilować przy użyciu przełącznika kompilatora /unsafe .

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!

Przykład 5. Utworzenie wystąpienia ciągu ze wskaźnika i zakresu tablicy

Poniższy przykład analizuje elementy tablicy znaków dla kropki lub wykrzyknika. Jeśli jeden zostanie znaleziony, tworzy wystąpienie ciągu z znaków w tablicy, która poprzedza symbol interpunkcyjny. Jeśli nie, tworzy wystąpienie ciągu z całą zawartością tablicy. Przykład języka C# należy skompilować przy użyciu przełącznika kompilatora /unsafe .

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

Przykład 6. Utworzenie wystąpienia ciągu ze wskaźnika do podpisanej tablicy bajtów

W poniższym przykładzie pokazano, jak utworzyć wystąpienie String klasy za pomocą konstruktora String(SByte*) .

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}"