System.String – konstruktor

Článek
01/30/2024

Tento článek obsahuje doplňující poznámky k referenční dokumentaci pro toto rozhraní API.

Syntaxe přetíženého konstruktoru

Konstruktory řetězců spadají do dvou kategorií: těch bez parametrů ukazatele a těch s parametry ukazatele. Konstruktory, které používají ukazatele, nejsou kompatibilní se specifikací CLS. Kromě toho Jazyk Visual Basic nepodporuje použití ukazatelů a jazyk C# vyžaduje kód, který používá ukazatele ke spuštění v nebezpečném kontextu. Další informace najdete v tématu nebezpečné.

Další pokyny k výběru přetížení najdete v tématu Jakou metodu zavolám?.

String(Char[] value)
Inicializuje novou instanci na hodnotu označenou polem znaků Unicode. Tento konstruktor zkopíruje znaky Unicode(Příklad 2: Použití pole znaků).

String(Char[] value, Int32 startIndex, Int32 length)
Inicializuje novou instanci na hodnotu označenou polem znaků Unicode, počáteční pozici znaku v rámci této matice a délku (Příklad 3: Použití části pole znaků a opakování jednoho znaku).

String(Char c, Int32 count)
Inicializuje novou instanci na hodnotu označenou zadaným znakem Unicode opakování zadaného počtu (Příklad 3: Použití části pole znaků a opakování jednoho znaku).

String(char* value)
(Nedodržuje předpisy CLS) Inicializuje novou instanci na hodnotu označenou ukazatelem na pole znaků Unicode, která je ukončena znakem null (U+0000 nebo '\0'). (Příklad 4: Použití ukazatele na pole znaků)

Oprávnění: SecurityCriticalAttributeVyžaduje úplný vztah důvěryhodnosti pro okamžitého volajícího. Tohoto člena nelze použít v kódu s částečnou důvěryhodností ani v transparentním kódu.

String(char* value, Int32 startIndex, Int32 length)
(Nedodržuje předpisy CLS) Inicializuje novou instanci na hodnotu označenou ukazatelem na pole znaků Unicode, počáteční pozici znaku v tomto poli a délku. Konstruktor zkopíruje znaky Unicode od value začátku indexu startIndex a končící na index startIndex + length - 1 (Příklad 5: Vytvoření instance řetězce z ukazatele a rozsahu pole).

String(SByte* value)
(Nedodržuje předpisy CLS) Inicializuje novou instanci na hodnotu označenou ukazatelem na pole 8bitové znaménka celých čísel. Pole se předpokládá, že představuje řetězec kódovaný pomocí aktuální systémové znakové stránky (to znamená kódování určené ).Encoding.Default Konstruktor zpracovává znaky z value umístění určeného ukazatelem, dokud se nedosáhne znaku null (0x00) (příklad 6: Vytvoření instance řetězce z ukazatele na pole se znaménkem bajtů).

String(SByte* value, Int32 startIndex, Int32 length)
(Nedodržuje předpisy CLS) Inicializuje novou instanci na hodnotu označenou ukazatelem na matici 8bitových celých čísel se znaménkem, počáteční pozice v dané matici a délka. Pole se předpokládá, že představuje řetězec kódovaný pomocí aktuální systémové znakové stránky (to znamená kódování určené ).Encoding.Default Konstruktor zpracovává znaky z hodnoty začínající na startIndex a končící na startIndex + length - 1 (Příklad 6: Vytvoření instance řetězce z ukazatele na pole se znaménkem bajtů).

String(SByte* value, Int32 startIndex, Int32 length, Encoding enc)
(Nedodržuje předpisy CLS) Inicializuje novou instanci na hodnotu označenou ukazatelem na pole 8bitových celých čísel se znaménkem, počáteční pozici v dané matici, délku a Encoding objekt.

Parametry

Tady je úplný seznam parametrů používaných String konstruktory, které neobsahují parametr ukazatele. Parametry, které používají jednotlivá přetížení, naleznete v předchozí syntaxi přetížení.

Parametr	Typ	Popis
`value`	Char[]	Pole znaků Unicode.
`c`	Char	Znak kódování Unicode
`startIndex`	Int32	Počáteční pozice `value` prvního znaku v novém řetězci. Výchozí hodnota: 0
`length`	Int32	Počet znaků, které `value` se mají zahrnout do nového řetězce. Výchozí hodnota: Array.Length
`count`	Int32	Počet opakování znaku `c` v novém řetězci. Pokud `count` je nula, hodnota nového objektu je String.Empty.

Tady je úplný seznam parametrů používaných String konstruktory, které obsahují parametr ukazatele. Parametry, které používají jednotlivá přetížení, naleznete v předchozí syntaxi přetížení.

Parametr	Typ	Popis
`value`	Char* nebo SByte*	Ukazatel na pole znaků Unicode s ukončenou hodnotou null nebo pole 8bitových celých čísel se znaménkem. Pokud `value` je nebo je `null` prázdné pole, hodnota nového řetězce je String.Empty.
`startIndex`	Int32	Index prvku pole, který definuje první znak v novém řetězci. Výchozí hodnota: 0
`length`	Int32	Počet prvků pole, které se mají použít k vytvoření nového řetězce. Pokud je délka nula, konstruktor vytvoří řetězec, jehož hodnota je String.Empty. Výchozí hodnota: Array.Length
`enc`	Encoding	Objekt, který určuje, jak `value` je pole kódováno. Výchozí hodnota: Encoding.Defaultnebo aktuální znaková stránka ANSI systému

Výjimky

Tady je seznam výjimek vyvolaných konstruktory, které neobsahují parametry ukazatele.

Výjimka	Podmínka	Vyvolané
ArgumentNullException	`value` je `null`.	String(Char[], Int32, Int32)
ArgumentOutOfRangeException	`startIndexcount` nebo`length` je menší než nula. nebo Součet `startIndex` a `length` je větší než počet prvků v `value`. nebo Hodnota `count` je menší než nula.	String(Char, Int32) String(Char[], Int32, Int32)

Tady je seznam výjimek vyvolaných konstruktory, které obsahují parametry ukazatele.

Výjimka	Podmínka	Vyvolané
ArgumentException	`value` určuje pole, které obsahuje neplatný znak Unicode. nebo `value` nebo `value` + `startIndex` určuje adresu, která je menší než 64 tisíc. nebo Novou String instanci nelze inicializovat z `value` pole bajtů, protože `value` nepoužívá výchozí kódování znakové stránky.	Všechny konstruktory s odkazy.
ArgumentNullException	`value` je null.	String(SByte) String(SByte, Int32, Int32) String(SByte*, Int32, Int32, Encoding)
ArgumentOutOfRangeException	Aktuální proces nemá přístup ke čtení všech adresovaných znaků. nebo `startIndex` nebo `length` je menší než nula, `value` + `startIndex` způsobit přetečení ukazatele nebo aktuální proces nemá přístup pro čtení ke všem adresám. nebo Délka nového řetězce je pro přidělení příliš velká.	Všechny konstruktory s odkazy.
AccessViolationException	`value`nebo `value` + + `startIndexlength` - 1 určuje neplatnou adresu.	String(SByte) String(SByte, Int32, Int32) String(SByte*, Int32, Int32, Encoding)

Jakou metodu mám volat?

To	Volání nebo použití
Vytvořte řetězec.	Přiřazení z řetězcového literálu nebo existujícího řetězce (příklad 1: Použití přiřazení řetězce)
Vytvoří řetězec z celého pole znaků.	String(Char[]) (Příklad 2: Použití pole znaků)
Vytvoří řetězec z části pole znaků.	String(Char[], Int32, Int32) (Příklad 3: Použití části pole znaků a opakování jednoho znaku)
Vytvořte řetězec, který několikrát opakuje stejný znak.	String(Char, Int32) (Příklad 3: Použití části pole znaků a opakování jednoho znaku)
Vytvořte řetězec z ukazatele na unicode nebo široké pole znaků.	String(Char*)
Pomocí ukazatele vytvořte řetězec z části pole znaků Unicode nebo širokého znaku.	String(Char*, Int32, Int32)
Vytvořte řetězec z pole C++ `char` .	String(SByte), String(SByte, Int32, Int32) nebo String(SByte*, Int32, Int32, Encoding)
Vytvořte řetězec ze znaků ASCII.	ASCIIEncoding.GetString

Vytváření řetězců

Nejčastěji používaný postup pro vytváření řetězců prostřednictvím kódu programu je jednoduché přiřazení, jak je znázorněno v příkladu 1. Třída String obsahuje také čtyři typy přetížení konstruktoru, které umožňují vytvářet řetězce z následujících hodnot:

Z pole znaků (pole znaků s kódováním UTF-16). Můžete vytvořit nový String objekt z znaků v celém poli nebo jeho části. Konstruktor String(Char[]) zkopíruje všechny znaky v poli do nového řetězce. Konstruktor String(Char[], Int32, Int32) zkopíruje znaky z indexu startIndex do indexu startIndex + length – 1 do nového řetězce. Pokud length je nula, hodnota nového řetězce je String.Empty.

Pokud váš kód opakovaně vytváří instance řetězců se stejnou hodnotou, můžete zlepšit výkon aplikace pomocí alternativních prostředků vytváření řetězců. Další informace naleznete v tématu Zpracování opakovaných řetězců.
Z jednoho znaku, který je duplikován nulou, jednou nebo vícekrát pomocí konstruktoru String(Char, Int32) . Pokud count je nula, hodnota nového řetězce je String.Empty.
Z ukazatele na pole znaků ukončených hodnotou null pomocí nebo String(Char*, Int32, Int32) konstruktoruString(Char*). Řetězec lze inicializovat pomocí celého pole nebo určeného rozsahu. Konstruktor zkopíruje posloupnost znaků Unicode počínaje zadaným ukazatelem nebo zadaným ukazatelem plus startIndex a pokračuje na konec pole nebo pro length znaky. Pokud value je ukazatel null nebo length je nula, konstruktor vytvoří řetězec, jehož hodnota je String.Empty. Pokud operace kopírování pokračuje na konec pole a pole není ukončeno hodnotou null, chování konstruktoru je závislé na systému. Taková podmínka může způsobit narušení přístupu.

Pokud pole obsahuje všechny vložené znaky null (U+0000 nebo '\0') a String(Char*, Int32, Int32) přetížení je voláno, instance řetězce obsahuje length znaky včetně všech vložených hodnot null. Následující příklad ukazuje, co se stane, když ukazatel na pole 10 prvků, který obsahuje dva znaky null předán metodě String(Char*, Int32, Int32) . Vzhledem k tomu, že adresa je začátek pole a všechny prvky v poli mají být přidány do řetězce, konstruktor vytvoří instanci řetězce s deseti znaky, včetně dvou vložených hodnot null. Pokud je však konstruktoru předáno String(Char*) stejné pole, je výsledkem řetězec se čtyřmi znaky, který neobsahuje první znak 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
```
Pole musí obsahovat znaky Unicode. V jazyce C++ to znamená, že pole znaků musí být definováno jako spravovaný Chartyp [] nebo nespravovanýwchar_t typ[].

String(Char*) Pokud je volána přetížení a pole není ukončeno null nebo pokud String(Char*, Int32, Int32) je volána přetížení a startIndex + length-1 obsahuje oblast, která je mimo paměť přidělenou pro posloupnost znaků, chování konstruktoru je závislé na systému a může dojít k narušení přístupu.
Z ukazatele na pole podepsaných bajtů. Řetězec lze inicializovat pomocí celého pole nebo určeného rozsahu. Sekvenci bajtů lze interpretovat pomocí výchozího kódování znakové stránky nebo kódování lze zadat ve volání konstruktoru. Pokud se konstruktor pokusí vytvořit instanci řetězce z celého pole, které není ukončeno hodnotou null, nebo pokud rozsah pole od valuestartIndexstartIndexlength + value + + -1 je mimo paměť přidělenou pro matici, chování tohoto konstruktoru je závislé na systému a může dojít k narušení přístupu.

Tři konstruktory, které jako parametr obsahují pole se znaky bajtů, jsou navrženy především pro převod pole C++ char na řetězec, jak je znázorněno v tomto příkladu:
```
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
```
Pokud pole obsahuje všechny znaky null (\0) nebo bajty, jejichž hodnota je 0 a String(SByte*, Int32, Int32) přetížení je voláno, instance řetězce obsahuje length znaky včetně všech vložených hodnot null. Následující příklad ukazuje, co se stane, když ukazatel na pole 10 prvků, který obsahuje dva znaky null předán metodě String(SByte*, Int32, Int32) . Vzhledem k tomu, že adresa je začátek pole a všechny prvky v poli mají být přidány do řetězce, konstruktor vytvoří instanci řetězce s deseti znaky, včetně dvou vložených hodnot null. Pokud je však konstruktoru předáno String(SByte*) stejné pole, je výsledkem řetězec se čtyřmi znaky, který neobsahuje první znak 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
```
Vzhledem k tomu, že String(SByte*) konstruktory interpretují String(SByte*, Int32, Int32)value pomocí výchozí znakové stránky ANSI, mohou volání těchto konstruktorů s identickými bajtovými poli vytvářet řetězce, které mají různé hodnoty v různých systémech.

Zpracování opakujících se řetězců

Aplikace, které parsují nebo dekódují streamy textu, často používají String(Char[], Int32, Int32) konstruktor nebo metodu StringBuilder.Append(Char[], Int32, Int32) k převodu sekvencí znaků na řetězec. Opakované vytváření nových řetězců se stejnou hodnotou místo vytváření a opakovaného použití jednoho řetězce ztrácí paměť. Pokud pravděpodobně vytvoříte stejnou řetězcovou hodnotu opakovaným voláním konstruktoru String(Char[], Int32, Int32) , i když předem nevíte, co tyto identické řetězcové hodnoty mohou být, můžete místo toho použít vyhledávací tabulku.

Předpokládejme například, že čtete a parsujete datový proud znaků ze souboru, který obsahuje značky a atributy XML. Při analýze datového proudu se opakovaně setkáte s určitými tokeny (to znamená posloupnosti znaků, které mají symbolický význam). Tokeny ekvivalentní řetězcům "0", "1", "true" a "false" se pravděpodobně vyskytují často v datovém proudu XML.

Místo převodu každého tokenu na nový řetězec můžete vytvořit System.Xml.NameTable objekt, který bude obsahovat běžně se vyskytující řetězce. Objekt NameTable zlepšuje výkon, protože načítá uložené řetězce bez přidělení dočasné paměti. Když narazíte na token, použijte NameTable.Get(Char[], Int32, Int32) metodu k načtení tokenu z tabulky. Pokud token existuje, vrátí metoda odpovídající řetězec. Pokud token neexistuje, použijte metodu NameTable.Add(Char[], Int32, Int32) pro vložení tokenu do tabulky a získání odpovídajícího řetězce.

Příklad 1: Použití přiřazení řetězce

Následující příklad vytvoří nový řetězec přiřazením řetězcového literálu. Vytvoří druhý řetězec přiřazením hodnoty prvního řetězce k němu. Jedná se o dva nejběžnější způsoby vytvoření instance nového String objektu.

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.

Příklad 2: Použití pole znaků

Následující příklad ukazuje, jak vytvořit nový String objekt z pole znaků.

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

Příklad 3: Použití části pole znaků a opakování jednoho znaku

Následující příklad ukazuje, jak vytvořit nový String objekt z části pole znaků a jak vytvořit nový String objekt, který obsahuje více výskytů jednoho 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)

Příklad 4: Použití ukazatele na pole znaků

Následující příklad ukazuje, jak vytvořit nový String objekt z ukazatele na pole znaků. Příklad jazyka C# musí být zkompilován pomocí přepínače kompilátoru /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!

Příklad 5: Vytvoření instance řetězce z ukazatele a rozsahu pole

Následující příklad zkoumá prvky pole znaků pro tečku nebo vykřičník. Pokud se najde, vytvoří instanci řetězce ze znaků v matici, která předchází symbolu interpunkce. Pokud ne, vytvoří instanci řetězce s celým obsahem pole. Příklad jazyka C# musí být zkompilován pomocí přepínače kompilátoru /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

Příklad 6: Vytvoření instance řetězce z ukazatele na pole se znaky bajtů

Následující příklad ukazuje, jak můžete vytvořit instanci String třídy pomocí konstruktoru 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}"