Constructeur System.String

Cet article vous offre des remarques complémentaires à la documentation de référence pour cette API.

Syntaxe du constructeur surchargé

Les constructeurs de chaînes appartiennent à deux catégories : celles sans paramètres de pointeur et celles avec des paramètres de pointeur. Les constructeurs qui utilisent des pointeurs ne sont pas conformes à CLS. En outre, Visual Basic ne prend pas en charge l’utilisation de pointeurs, et C# nécessite du code qui utilise des pointeurs pour s’exécuter dans un contexte non sécurisé. Pour plus d’informations, consultez unsafe.

Pour obtenir des conseils supplémentaires sur le choix d’une surcharge, consultez Quelle méthode dois-je appeler ?.

String(Char[] value)
Initialise la nouvelle instance à la valeur indiquée par un tableau de caractères Unicode. Ce constructeur copie les caractères Unicode (exemple 2 : utiliser un tableau de caractères).

String(Char[] value, Int32 startIndex, Int32 length)
Initialise la nouvelle instance à la valeur indiquée par un tableau de caractères Unicode, une position de caractère de départ dans ce tableau et une longueur (Exemple 3 : Utiliser une partie d’un tableau de caractères et répéter un caractère unique).

String(Char c, Int32 count)
Initialise la nouvelle instance à la valeur indiquée par un caractère Unicode spécifié répété un nombre spécifié de fois (exemple 3 : utiliser une partie d’un tableau de caractères et répéter un seul caractère).

String(char* value)
(Non conforme CLS) Initialise la nouvelle instance à la valeur indiquée par un pointeur vers un tableau de caractères Unicode qui se termine par un caractère Null (U+0000 ou '\0'). (Exemple 4 : Utiliser un pointeur vers un tableau de caractères).

Autorisation : SecurityCriticalAttribute, nécessite une confiance totale pour l’appelant immédiat. Ce membre ne peut pas être utilisé par du code partiellement approuvé ou transparent.

String(char* value, Int32 startIndex, Int32 length)
(Non conforme CLS) Initialise la nouvelle instance à la valeur indiquée par un pointeur vers un tableau de caractères Unicode, une position de caractère de départ dans ce tableau et une longueur. Le constructeur copie les caractères Unicode du value début à l’index startIndex et se terminant à l’index startIndexlength + - 1 (Exemple 5 : instancier une chaîne à partir d’un pointeur et d’une plage d’un tableau).

Autorisation : SecurityCriticalAttribute, nécessite une confiance totale pour l’appelant immédiat. Ce membre ne peut pas être utilisé par du code partiellement approuvé ou transparent.

String(SByte* value)
(Non conforme CLS) Initialise la nouvelle instance à la valeur indiquée par un pointeur vers un tableau d’entiers signés 8 bits. Le tableau est supposé représenter une chaîne encodée à l’aide de la page de codes système actuelle (autrement dit, l’encodage spécifié par Encoding.Default). Le constructeur traite les caractères à partir de value l’emplacement spécifié par le pointeur jusqu’à ce qu’un caractère null (0x00) soit atteint (exemple 6 : instancier une chaîne d’un pointeur vers un tableau d’octets signé).

Autorisation : SecurityCriticalAttribute, nécessite une confiance totale pour l’appelant immédiat. Ce membre ne peut pas être utilisé par du code partiellement approuvé ou transparent.

String(SByte* value, Int32 startIndex, Int32 length)
(Non conforme CLS) Initialise la nouvelle instance à la valeur indiquée par un pointeur vers un tableau d’entiers signés 8 bits, une position de départ dans ce tableau et une longueur. Le tableau est supposé représenter une chaîne encodée à l’aide de la page de codes système actuelle (autrement dit, l’encodage spécifié par Encoding.Default). Le constructeur traite les caractères de la valeur commençant à startIndex startIndexlength + - 1 (Exemple 6 : instancier une chaîne d’un pointeur vers un tableau d’octets signé).

Autorisation : SecurityCriticalAttribute, nécessite une confiance totale pour l’appelant immédiat. Ce membre ne peut pas être utilisé par du code partiellement approuvé ou transparent.

String(SByte* value, Int32 startIndex, Int32 length, Encoding enc)
(Non conforme CLS) Initialise la nouvelle instance à la valeur indiquée par un pointeur vers un tableau d’entiers signés 8 bits, une position de départ dans ce tableau, une longueur et un Encoding objet.

Autorisation : SecurityCriticalAttribute, nécessite une confiance totale pour l’appelant immédiat. Ce membre ne peut pas être utilisé par du code partiellement approuvé ou transparent.

Paramètres

Voici une liste complète des paramètres utilisés par String les constructeurs qui n’incluent pas de paramètre de pointeur. Pour connaître les paramètres utilisés par chaque surcharge, consultez la syntaxe de surcharge ci-dessus.

Voici une liste complète des paramètres utilisés par String les constructeurs qui incluent un paramètre de pointeur. Pour connaître les paramètres utilisés par chaque surcharge, consultez la syntaxe de surcharge ci-dessus.

Exceptions

Voici une liste d’exceptions levées par les constructeurs qui n’incluent pas de paramètres de pointeur.

Voici une liste d’exceptions levées par les constructeurs qui incluent des paramètres de pointeur.

Quelle méthode dois-je appeler ?

Créer des chaînes

La technique la plus couramment utilisée pour créer des chaînes par programmation est une affectation simple, comme illustré dans l’exemple 1. La String classe inclut également quatre types de surcharges de constructeur qui vous permettent de créer des chaînes à partir des valeurs suivantes :

• À partir d’un tableau de caractères (tableau de caractères codés en UTF-16). Vous pouvez créer un String objet à partir des caractères de l’ensemble du tableau ou d’une partie de celui-ci. Le String(Char[]) constructeur copie tous les caractères du tableau dans la nouvelle chaîne. Le String(Char[], Int32, Int32) constructeur copie les caractères de l’index startIndex vers l’index startIndex + length - 1 vers la nouvelle chaîne. Si length elle est égale à zéro, la valeur de la nouvelle chaîne est String.Empty.

  Si votre code instancie à plusieurs reprises des chaînes qui ont la même valeur, vous pouvez améliorer les performances de l’application à l’aide d’un autre moyen de créer des chaînes. Pour plus d’informations, consultez Gérer les chaînes répétitives.

• À partir d’un caractère unique qui est dupliqué zéro, un ou plusieurs fois, à l’aide du String(Char, Int32) constructeur. Si count elle est égale à zéro, la valeur de la nouvelle chaîne est String.Empty.

• À partir d’un pointeur vers un tableau de caractères terminé par null, à l’aide du ou String(Char*, Int32, Int32) du String(Char*) constructeur. Le tableau entier ou une plage spécifiée peut être utilisé pour initialiser la chaîne. Le constructeur copie une séquence de caractères Unicode à partir du pointeur spécifié ou du pointeur spécifié plus startIndex et passe à la fin du tableau ou des length caractères. S’il value s’agit d’un pointeur Null ou length est égal à zéro, le constructeur crée une chaîne dont la valeur est String.Empty. Si l’opération de copie passe à la fin du tableau et que le tableau n’est pas terminé par null, le comportement du constructeur dépend du système. Une telle condition peut entraîner une violation d’accès.

  Si le tableau contient des caractères Null incorporés (U+0000 ou '\0') et que la String(Char*, Int32, Int32) surcharge est appelée, l’instance de chaîne contient length des caractères incluant des valeurs Null incorporées. L’exemple suivant montre ce qui se passe lorsqu’un pointeur vers un tableau de 10 éléments incluant deux caractères Null est passé à la String(Char*, Int32, Int32) méthode. Étant donné que l’adresse est le début du tableau et que tous les éléments du tableau doivent être ajoutés à la chaîne, le constructeur instancie une chaîne avec dix caractères, y compris deux valeurs Null incorporées. En revanche, si le même tableau est passé au String(Char*) constructeur, le résultat est une chaîne à quatre caractères qui n’inclut pas le premier caractère 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
  

  Le tableau doit contenir des caractères Unicode. En C++, cela signifie que le tableau de caractères doit être défini en tant que type [] managé ou non managéCharwchar_t[].

  Si la String(Char*) surcharge est appelée et que le tableau n’est pas terminé par null, ou si la String(Char*, Int32, Int32) surcharge est appelée et startIndex + length-1 inclut une plage qui est en dehors de la mémoire allouée pour la séquence de caractères, le comportement du constructeur dépend du système et une violation d’accès peut se produire.

• À partir d’un pointeur vers un tableau d’octets signé. Le tableau entier ou une plage spécifiée peut être utilisé pour initialiser la chaîne. La séquence d’octets peut être interprétée à l’aide de l’encodage de page de codes par défaut, ou un encodage peut être spécifié dans l’appel du constructeur. Si le constructeur tente d’instancier une chaîne à partir d’un tableau entier qui n’est pas terminé par null ou si la plage du tableau de value + startIndex - + value + startIndexlength1 est en dehors de la mémoire allouée pour le tableau, le comportement de ce constructeur dépend du système et une violation d’accès peut se produire.

  Les trois constructeurs qui incluent un tableau d’octets signés en tant que paramètre sont conçus principalement pour convertir un tableau C++ char en chaîne, comme illustré dans cet exemple :

  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
  

  Si le tableau contient des caractères null ('\0') ou des octets dont la valeur est 0 et que la String(SByte*, Int32, Int32) surcharge est appelée, l’instance de chaîne contient length des caractères incluant des valeurs Null incorporées. L’exemple suivant montre ce qui se passe lorsqu’un pointeur vers un tableau de 10 éléments incluant deux caractères Null est passé à la String(SByte*, Int32, Int32) méthode. Étant donné que l’adresse est le début du tableau et que tous les éléments du tableau doivent être ajoutés à la chaîne, le constructeur instancie une chaîne avec dix caractères, y compris deux valeurs Null incorporées. En revanche, si le même tableau est passé au String(SByte*) constructeur, le résultat est une chaîne à quatre caractères qui n’inclut pas le premier caractère 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
  

  Étant donné que les String(SByte*) constructeurs interprètent String(SByte*, Int32, Int32) value à l’aide de la page de codes ANSI par défaut, l’appel de ces constructeurs avec des tableaux d’octets identiques peut créer des chaînes qui ont des valeurs différentes sur différents systèmes.

Gérer les chaînes répétitives

Les applications qui analysent ou décodent des flux de texte utilisent souvent le String(Char[], Int32, Int32) constructeur ou la StringBuilder.Append(Char[], Int32, Int32) méthode pour convertir des séquences de caractères en chaîne. La création répétée de nouvelles chaînes avec la même valeur au lieu de créer et réutiliser une chaîne perd de la mémoire. Si vous êtes susceptible de créer la même valeur de chaîne à plusieurs reprises en appelant le constructeur, même si vous ne savez pas à l’avance quelles sont ces valeurs de chaîne identiques, vous pouvez utiliser une table de choix à la String(Char[], Int32, Int32) place.

Par exemple, supposons que vous lisez et analysez un flux de caractères à partir d’un fichier qui contient des balises et des attributs XML. Lorsque vous analysez le flux, vous rencontrez à plusieurs reprises certains jetons (c’est-à-dire des séquences de caractères qui ont une signification symbolique). Les jetons équivalents aux chaînes « 0 », « 1 », « true » et « false » sont susceptibles de se produire fréquemment dans un flux XML.

Au lieu de convertir chaque jeton en nouvelle chaîne, vous pouvez créer un System.Xml.NameTable objet pour contenir des chaînes couramment présentes. L’objet NameTable améliore les performances, car il récupère des chaînes stockées sans allouer de mémoire temporaire. Lorsque vous rencontrez un jeton, utilisez la NameTable.Get(Char[], Int32, Int32) méthode pour récupérer le jeton à partir de la table. Si le jeton existe, la méthode retourne la chaîne correspondante. Si le jeton n’existe pas, utilisez la NameTable.Add(Char[], Int32, Int32) méthode pour insérer le jeton dans la table et obtenir la chaîne correspondante.

Exemple 1 : Utiliser l’attribution de chaîne

L’exemple suivant crée une chaîne en lui affectant un littéral de chaîne. Il crée une deuxième chaîne en lui affectant la valeur de la première chaîne. Il s’agit des deux méthodes les plus courantes pour instancier un nouvel String objet.

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.

Exemple 2 : Utiliser un tableau de caractères

L’exemple suivant montre comment créer un String objet à partir d’un tableau de caractères.

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

Exemple 3 : Utiliser une partie d’un tableau de caractères et répéter un seul caractère

L’exemple suivant montre comment créer un String objet à partir d’une partie d’un tableau de caractères et comment créer un String objet qui contient plusieurs occurrences d’un seul caractère.

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

Exemple 4 : Utiliser un pointeur vers un tableau de caractères

L’exemple suivant montre comment créer un String objet à partir d’un pointeur vers un tableau de caractères. L’exemple C# doit être compilé à l’aide du commutateur du /unsafe compilateur.

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!

Exemple 5 : instancier une chaîne à partir d’un pointeur et d’une plage d’un tableau

L’exemple suivant examine les éléments d’un tableau de caractères pour un point d’exclamation ou un point d’exclamation. Si l’un d’eux est trouvé, il instancie une chaîne à partir des caractères du tableau qui précèdent le symbole de ponctuation. Si ce n’est pas le cas, il instancie une chaîne avec l’intégralité du contenu du tableau. L’exemple C# doit être compilé à l’aide du commutateur du /unsafe compilateur.

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

Exemple 6 : instancier une chaîne d’un pointeur vers un tableau d’octets signé

L’exemple suivant montre comment créer une instance de la String classe avec le String(SByte*) constructeur.

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