System.String constructor

Overbelaste constructorsyntaxis

Tekenreeksconstructors worden onderverdeeld in twee categorieën: die zonder pointerparameters en die met pointerparameters. De constructors die gebruikmaken van aanwijzers zijn niet CLS-compatibel. Bovendien biedt Visual Basic geen ondersteuning voor het gebruik van aanwijzers en C# vereist code die gebruikmaakt van aanwijzers om in een onveilige context uit te voeren. Zie onveilig voor meer informatie.

Zie Welke methode roep ik aan voor aanvullende richtlijnen voor het kiezen van een overbelasting.

String(Char[] value)
Initialiseert het nieuwe exemplaar naar de waarde die wordt aangegeven door een matrix met Unicode-tekens. Met deze constructor worden Unicode-tekens gekopieerd (voorbeeld 2: Een tekenmatrix gebruiken).

String(Char[] value, Int32 startIndex, Int32 length)
Initialiseert het nieuwe exemplaar naar de waarde die wordt aangegeven door een matrix met Unicode-tekens, een begintekenpositie in die matrix en een lengte (voorbeeld 3: Een gedeelte van een tekenmatrix gebruiken en één teken herhalen).

String(Char c, Int32 count)
Initialiseert het nieuwe exemplaar naar de waarde die wordt aangegeven door een opgegeven Unicode-teken dat een opgegeven aantal keren wordt herhaald (voorbeeld 3: Een deel van een tekenmatrix gebruiken en één teken herhalen).

String(char* value)
(Niet cls-compatibel) Initialiseert het nieuwe exemplaar naar de waarde die wordt aangegeven door een aanwijzer naar een matrix met Unicode-tekens die wordt beëindigd door een null-teken (U+0000 of \0). (Voorbeeld 4: Een aanwijzer gebruiken voor een tekenmatrix).

Machtiging: SecurityCriticalAttribute, vereist volledig vertrouwen voor de directe beller. Dit lid kan niet worden gebruikt door gedeeltelijk vertrouwde of transparante code.

String(char* value, Int32 startIndex, Int32 length)
(Niet cls-compatibel) Initialiseert het nieuwe exemplaar naar de waarde die wordt aangegeven door een aanwijzer naar een matrix met Unicode-tekens, een begintekenpositie binnen die matrix en een lengte. De constructor kopieert de Unicode-tekens vanaf value index startIndex en eindigt bij index startIndex + length - 1 (voorbeeld 5: Een tekenreeks instantiëren vanuit een aanwijzer en een bereik van een matrix).

Machtiging: SecurityCriticalAttribute, vereist volledig vertrouwen voor de directe beller. Dit lid kan niet worden gebruikt door gedeeltelijk vertrouwde of transparante code.

String(SByte* value)
(Niet cls-compatibel) Initialiseert het nieuwe exemplaar naar de waarde die wordt aangegeven door een aanwijzer naar een matrix van 8-bits ondertekende gehele getallen. De matrix wordt verondersteld een tekenreeks weer te geven die is gecodeerd met behulp van de huidige systeemcodepagina (dat wil gezegd de codering die is opgegeven door Encoding.Default). De constructor verwerkt tekens vanaf value, beginnend bij de locatie die is opgegeven door de pointer, totdat een null-teken (0x00) is bereikt (Voorbeeld 6: Een tekenreeks instantiëren vanaf een pointer naar een signed byte array).

Machtiging: SecurityCriticalAttribute, vereist volledig vertrouwen voor de directe beller. Dit lid kan niet worden gebruikt door gedeeltelijk vertrouwde of transparante code.

String(SByte* value, Int32 startIndex, Int32 length)
(Niet cls-compatibel) Initialiseert het nieuwe exemplaar naar de waarde die wordt aangegeven door een aanwijzer naar een matrix met 8-bits ondertekende gehele getallen, een beginpositie binnen die matrix en een lengte. De matrix wordt verondersteld een tekenreeks weer te geven die is gecodeerd met behulp van de huidige systeemcodepagina (dat wil gezegd de codering die is opgegeven door Encoding.Default). De constructor verwerkt tekens van de waarde die begint bij startIndex en eindigt op startIndex + length- 1 (voorbeeld 6: Een tekenreeks instantiëren van een aanwijzer naar een ondertekende bytematrix).

Machtiging: SecurityCriticalAttribute, vereist volledig vertrouwen voor de directe beller. Dit lid kan niet worden gebruikt door gedeeltelijk vertrouwde of transparante code.

String(SByte* value, Int32 startIndex, Int32 length, Encoding enc)
(Niet cls-compatibel) Initialiseert het nieuwe exemplaar naar de waarde die wordt aangegeven door een aanwijzer naar een matrix van 8-bits ondertekende gehele getallen, een beginpositie binnen die matrix, een lengte en een Encoding object.

Machtiging: SecurityCriticalAttribute, vereist volledig vertrouwen voor de directe beller. Dit lid kan niet worden gebruikt door gedeeltelijk vertrouwde of transparante code.

Parameterwaarden

Hier volgt een volledige lijst met parameters die worden gebruikt door String constructors die geen aanwijzerparameter bevatten. Zie de bovenstaande syntaxis voor overbelasting voor de parameters die door elke overbelasting worden gebruikt.

Hier volgt een volledige lijst met parameters die worden gebruikt door String constructors die een aanwijzerparameter bevatten. Zie de bovenstaande syntaxis voor overbelasting voor de parameters die door elke overbelasting worden gebruikt.

Uitzonderingen

Hier volgt een lijst met uitzonderingen die worden gegenereerd door constructors die geen aanwijzerparameters bevatten.

Hier volgt een lijst met uitzonderingen die worden gegenereerd door constructors met aanwijzerparameters.

Welke methode roep ik aan?

Tekenreeksen maken

De meest gebruikte techniek voor het programmatisch genereren van tekenreeksen is eenvoudige toewijzing, zoals geïllustreerd in Voorbeeld 1. De String klasse bevat ook vier typen constructoroverbelastingen waarmee u tekenreeksen kunt maken op basis van de volgende waarden:

• Uit een tekenmatrix (een matrix met UTF-16-gecodeerde tekens). U kunt een nieuw String object maken op basis van de tekens in de hele matrix of een deel ervan. De String(Char[]) constructor kopieert alle tekens in de matrix naar de nieuwe tekenreeks. De String(Char[], Int32, Int32) constructor kopieert de tekens van index startIndex tot index startIndex + length - 1 naar de nieuwe tekenreeks. Als length nul is, is String.Emptyde waarde van de nieuwe tekenreeks .

  Als met uw code herhaaldelijk tekenreeksen worden geïnstantieerd die dezelfde waarde hebben, kunt u de prestaties van toepassingen verbeteren met behulp van een alternatieve methode voor het maken van tekenreeksen. Zie Terugkerende tekenreeksen verwerken voor meer informatie.

• Van één teken dat nul, een of meer keren wordt gedupliceerd met behulp van de String(Char, Int32) constructor. Als count nul is, is String.Emptyde waarde van de nieuwe tekenreeks .

• Van een aanwijzer naar een door null beëindigde tekenmatrix met behulp van de String(Char*) of String(Char*, Int32, Int32) constructor. De hele matrix of een opgegeven bereik kan worden gebruikt om de tekenreeks te initialiseren. De constructor kopieert een reeks Unicode-tekens die beginnen vanaf de opgegeven aanwijzer of vanaf de opgegeven aanwijzer plus startIndex en doorgaan naar het einde van de matrix of voor length tekens. Als value dit een null-aanwijzer is of length nul is, maakt de constructor een tekenreeks waarvan de waarde is String.Empty. Als de kopieerbewerking naar het einde van de matrix gaat en de matrix niet null-beëindigd is, is het constructorgedrag systeemafhankelijk. Een dergelijke voorwaarde kan een schending van de toegang veroorzaken.

  Als de array ingesloten null-tekens bevat (U+0000 of \0) en de overload wordt aangeroepen, bevat de string-instantie String(Char*, Int32, Int32) tekens, inclusief ingesloten null-tekens. In het volgende voorbeeld ziet u wat er gebeurt wanneer een aanwijzer naar een matrix van 10 elementen met twee null-tekens wordt doorgegeven aan de String(Char*, Int32, Int32) methode. Omdat het adres het begin is van de matrix en alle elementen in de matrix moeten worden toegevoegd aan de tekenreeks, wordt door de constructor een tekenreeks geïnstitueerd met tien tekens, inclusief twee ingesloten null's. Als dezelfde matrix echter wordt doorgegeven aan de String(Char*) constructor, is het resultaat een tekenreeks met vier tekens die niet het eerste null-teken bevat.

  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
  

  De matrix moet Unicode-tekens bevatten. In C++betekent dit dat de tekenmatrix moet worden gedefinieerd als het beheerde Char[] type of het niet-beheerdewchar_t[] type.

  Als de String(Char*) overbelasting wordt aangeroepen en de matrix niet null-beëindigd is, of als de String(Char*, Int32, Int32) overbelasting wordt aangeroepen en startIndex + length-1 een bereik bevat dat buiten het geheugen valt dat is toegewezen voor de reeks tekens, is het gedrag van de constructor systeemafhankelijk en kan er een toegangsfout optreden.

• Van een aanwijzer naar een ondertekende bytematrix. De hele matrix of een opgegeven bereik kan worden gebruikt om de tekenreeks te initialiseren. De volgorde van bytes kan worden geïnterpreteerd met behulp van de standaardcodering van codepagina's of een codering kan worden opgegeven in de constructoraanroep. Als de constructor probeert een tekenreeks te instantiëren van een hele matrix die niet null-beëindigd is of als het bereik van de matrix van value + startIndex -value + startIndex + length1 buiten het geheugen valt dat voor de matrix is toegewezen, is het gedrag van deze constructor systeemafhankelijk en kan er een schending van de toegang optreden.

  De drie constructors die een ondertekende bytematrix als parameter bevatten, zijn voornamelijk ontworpen om een C++ char -matrix te converteren naar een tekenreeks, zoals wordt weergegeven in dit voorbeeld:

  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
  

  Als de array lege tekens ('\0') of bytes bevat waarvan de waarde 0 is en de String(SByte*, Int32, Int32) overbelasting wordt aangeroepen, bevat de tekenreeksinstantie length tekens, inclusief eventuele ingesloten null-tekens. In het volgende voorbeeld ziet u wat er gebeurt wanneer een aanwijzer naar een matrix van 10 elementen met twee null-tekens wordt doorgegeven aan de String(SByte*, Int32, Int32) methode. Omdat het adres het begin is van de matrix en alle elementen in de matrix moeten worden toegevoegd aan de tekenreeks, wordt door de constructor een tekenreeks geïnstitueerd met tien tekens, inclusief twee ingesloten null's. Als dezelfde matrix echter wordt doorgegeven aan de String(SByte*) constructor, is het resultaat een tekenreeks met vier tekens die niet het eerste null-teken bevat.

  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
  

  Omdat de String(SByte*) en String(SByte*, Int32, Int32) constructors value interpreteren met behulp van de standaard ANSI-codepagina, kunnen deze constructors met identieke bytematrices tekenreeksen maken die verschillende waarden op verschillende systemen hebben.

Terugkerende tekenreeksen verwerken

Apps die tekststromen parseren of decoderen, gebruiken vaak de String(Char[], Int32, Int32) constructor of de StringBuilder.Append(Char[], Int32, Int32) methode om reeksen tekens te converteren naar een tekenreeks. Herhaaldelijk nieuwe tekenreeksen maken met dezelfde waarde in plaats van één tekenreeks te maken en opnieuw te gebruiken, verspilt geheugen. Als u waarschijnlijk dezelfde tekenreekswaarde herhaaldelijk maakt door de String(Char[], Int32, Int32) constructor aan te roepen, zelfs als u niet van tevoren weet wat deze identieke tekenreekswaarden kunnen zijn, kunt u in plaats daarvan een opzoektabel gebruiken.

Stel dat u een stroom tekens uit een bestand met XML-tags en -kenmerken leest en parseert. Wanneer u de gegevensstroom analyseert, komt u herhaaldelijk bepaalde tokens tegen (dat wil zeggen, reeksen tekens met een symbolische betekenis). Tokens die gelijk zijn aan de tekenreeksen '0', '1', 'true' en 'false' komen waarschijnlijk vaak voor in een XML-stroom.

In plaats van elk token te converteren naar een nieuwe tekenreeks, kunt u een System.Xml.NameTable object maken waarin veel voorkomende tekenreeksen worden opgeslagen. Het NameTable object verbetert de prestaties, omdat het opgeslagen tekenreeksen ophaalt zonder tijdelijk geheugen toe te wijzen. Wanneer u een token tegenkomt, gebruikt u de NameTable.Get(Char[], Int32, Int32) methode om het token op te halen uit de tabel. Als het token bestaat, retourneert de methode de bijbehorende tekenreeks. Als het token niet bestaat, gebruikt u de NameTable.Add(Char[], Int32, Int32) methode om het token in de tabel in te voegen en de bijbehorende tekenreeks op te halen.

Voorbeeld 1: Tekenreekstoewijzing gebruiken

In het volgende voorbeeld wordt een nieuwe tekenreeks gemaakt door deze een letterlijke tekenreeks toe te wijzen. Er wordt een tweede tekenreeks gemaakt door de waarde van de eerste tekenreeks eraan toe te wijzen. Dit zijn de twee meest voorkomende manieren om een nieuw String object te instantiëren.

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.

Voorbeeld 2: Een tekenmatrix gebruiken

In het volgende voorbeeld ziet u hoe u een nieuw String object maakt op basis van een tekenmatrix.

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

Voorbeeld 3: Een gedeelte van een tekenmatrix gebruiken en één teken herhalen

In het volgende voorbeeld ziet u hoe u een nieuw String object maakt op basis van een deel van een tekenmatrix en hoe u een nieuw String object maakt dat meerdere exemplaren van één teken bevat.

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

Voorbeeld 4: Een aanwijzer gebruiken voor een tekenmatrix

In het volgende voorbeeld ziet u hoe u een nieuw String object maakt vanuit een aanwijzer naar een matrix met tekens. Het C#-voorbeeld moet worden gecompileerd met behulp van de /unsafe compilerswitch.

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!

Voorbeeld 5: Een tekenreeks instantiëren vanuit een aanwijzer en een bereik van een matrix

In het volgende voorbeeld worden de elementen van een tekenmatrix onderzocht voor een punt of een uitroepteken. Als er één wordt gevonden, instantiëert het een string uit de tekens in de array die aan het interpunctiesymbool voorafgaan. Als dat niet het geval is, wordt er een tekenreeks geïnstantieerd met de volledige inhoud van de array. Het C#-voorbeeld moet worden gecompileerd met behulp van de /unsafe compilerswitch.

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

Voorbeeld 6: Een tekenreeks instantiëren van een aanwijzer naar een ondertekende bytematrix

In het volgende voorbeeld ziet u hoe u een exemplaar van de String klasse met de String(SByte*) constructor kunt maken.

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