Konstruktor System.String

Uwaga / Notatka

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)
Inicjalizuje nowe wystąpienie wartością wskazaną 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ątkową znaku w tej tablicy oraz długość (przykład 3: użycia 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 nadawcy. Członek 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, zaczynając od indeksu startIndex i kończąc na indeksie startIndex + length - 1 (Przykład 5: Utworzenie wystąpienia ciągu ze wskaźnika i zakresu tablicy).

Uprawnienie: SecurityCriticalAttribute, wymaga pełnego zaufania dla bezpośredniego wywołującego. Ten członek nie może być używany w częściowo zaufanym lub przejrzystym kodzie.

String(SByte* value)
(Niezgodne ze specyfikacją CLS) Tworzy nowe wystąpienie dla wartości wskazanej przez wskaźnik wskazujący na tablicę 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.Default). Konstruktor przetwarza znaki z value począwszy od lokalizacji określonej przez wskaźnik aż do napotkania znaku null (0x00) (PRZYKŁAD 6: Utworzenie wystąpienia łańcucha znaków ze wskaźnika do znakowanej tablicy bajtów).

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

String(SByte* value, Int32 startIndex, Int32 length)
(Niezgodne ze specyfikacją CLS) Inicjuje nowe wystąpienie na podstawie wartości wskazanej przez wskaźnik do tablicy 8-bitowych liczb całkowitych ze znakiem, z podaniem pozycji początkowej w tej tablicy oraz 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.Default). Konstruktor przetwarza znaki z wartości, zaczynając od startIndex i kończąc na startIndex + length - 1 (Przykład 6: Utworzenie wystąpienia ciągu ze wskaźnika na tablicę bajtów ze znakiem).

Uprawnienie: SecurityCriticalAttribute, wymaga pełnego zaufania dla bezpośredniego obiektu wywołującego. Ten członek nie może być używany w częściowo zaufanym lub przejrzystym kodzie.

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.

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

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	Typ	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 w value, którą należy uwzględnić 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	Typ	Opis
value	Char* — lub — SByte*	Wskaźnik do tablicy znaków Unicode zakończonej znakiem null lub tablicy 8-bitowych liczb całkowitych 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, lengthlub count jest mniejsza 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 wystąpienia String z tablicy bajtów value, ponieważ value nie używa domyślnego kodowania strony kodowej.	Wszystkie konstruktory ze wskaźnikami.
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 mniejszy niż zero, value + startIndex powodują przepełnienie wskaźnika, lub bieżący proces nie ma dostępu do odczytu wszystkich adresowanych znaków. — lub — Długość nowego ciągu jest zbyt duża, aby przydzielić.	Wszystkie konstruktory ze wskaźnikami.
AccessViolationException	value, lub value + startIndex + length - 1, określa nieprawidłowy adres.	String(SByte*) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32, Encoding)

Jaką metodę wywołać?

To	Zadzwoń lub użyj
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życie 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 znaków szerokich.	String(Char*)
Utwórz ciąg na podstawie części tablicy znaków Unicode lub szerokich znaków 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

Twórz ciągi

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 obiekt String z znaków w całej tablicy lub tylko jej części. Konstruktor String(Char[]) kopiuje wszystkie znaki w tablicy do nowego ciągu. Konstruktor String(Char[], Int32, Int32) kopiuje znaki z indeksu startIndex do indeksu startIndex + length - 1 do nowego ciągu znaków. 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) . Można użyć całej tablicy lub jej określonego zakresu do zainicjowania ciągu. 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łane, wystąpienie ciągu zawiera length znaki, wliczając wszystkie osadzone wartości null. W poniższym przykładzie pokazano, co się stanie, gdy wskaźnik do tablicy z 10 elementami zawierającymi dwa znaki zerowe jest przekazywany do metody String(Char*, Int32, Int32). Ponieważ adres jest początkiem tablicy, a wszystkie elementy tablicy mają być dodane do ciągu, konstruktor tworzy instancję ciągu składającą się z dziesięciu znaków, w tym dwóch osadzonych wartości zerowych. 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 typ zarządzany Char[] lub typ niezarządzany wchar_t[].

  String(Char*) Jeśli wywoływane jest przeciążenie, a tablica nie kończy się wartością null, lub jeśli wywoływane jest String(Char*, Int32, Int32) przeciążenie i startIndex + length-1 zawiera zakres, który wykracza poza pamięć przydzieloną dla sekwencji znaków, wtedy zachowanie konstruktora jest zależne od systemu i może dojść do naruszenia dostępu.

• Od wskaźnika do podpisanej tablicy bajtów. Do zainicjowania ciągu można wykorzystać tablicę w całości lub jej określony zakres. 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 od value + startIndex do value + startIndex + length -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 zerowe ('\0') lub bajty wartości 0, a wywoływane jest przeciążenie String(SByte*, Int32, Int32), wystąpienie ciągu zawiera znaki length, w tym wszelkie osadzone znaki zerowe. W poniższym przykładzie pokazano, co się stanie, gdy wskaźnik do tablicy zawierającej 10 elementów, w tym dwa znaki null, jest przekazywany do metody String(SByte*, Int32, Int32). 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 dwóch osadzonych 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*) i String(SByte*, Int32, Int32) interpretują value za pomocą domyślnej strony kodowej ANSI, dlatego wywoływanie tych konstruktorów z identycznymi tablicami bajtów może prowadzić do powstania ciągów, które mają różne wartości na 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. Wielokrotne tworzenie nowych ciągów o tej samej wartości zamiast utworzenia i ponownego użycia jednego ciągu powoduje marnowanie pamięci. Jeśli istnieje prawdopodobieństwo, że wielokrotnie tworzysz tę samą wartość ciągu, wywołując konstruktor String(Char[], Int32, Int32), nawet jeśli nie wiesz wcześniej, jakie będą 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. Gdy napotkasz token, użyj metody NameTable.Get(Char[], Int32, Int32), 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życie 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 instancjonowania nowego obiektu String.

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: Tworzenie ciągu znaków za pomocą wskaźnika i zakresu tablicy

Poniższy przykład analizuje elementy tablicy znaków w poszukiwaniu obecności kropki lub wykrzyknika. Jeśli któryś zostanie znaleziony, tworzony jest ciąg z znaków w tablicy, które poprzedzają symbol interpunkcyjny. Jeśli nie, przekształca całą zawartość tablicy w ciąg. 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 instancji ciągu ze wskaźnika do tablicy bajtów ze znakiem

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