Costruttore System.String

Questo articolo fornisce osservazioni supplementari alla documentazione di riferimento per questa API.

Sintassi del costruttore di overload

I costruttori di stringhe rientrano in due categorie: quelle senza parametri puntatore e quelle con parametri puntatore. I costruttori che usano puntatori non sono conformi a CLS. Visual Basic non supporta inoltre l'uso dei puntatori e C# richiede codice che usa puntatori per l'esecuzione in un contesto non sicuro. Per altre informazioni, vedere unsafe.

Per altre indicazioni sulla scelta di un overload, vedere Quale metodo chiamare?.

String(Char[] value)
Inizializza la nuova istanza del valore indicato da una matrice di caratteri Unicode. Questo costruttore copia i caratteri Unicode (esempio 2: Usare una matrice di caratteri).

String(Char[] value, Int32 startIndex, Int32 length)
Inizializza la nuova istanza del valore indicato da una matrice di caratteri Unicode, una posizione del carattere iniziale all'interno di tale matrice e una lunghezza (esempio 3: usare una parte di una matrice di caratteri e ripetere un singolo carattere).

String(Char c, Int32 count)
Inizializza la nuova istanza del valore indicato da un carattere Unicode specificato ripetuto un numero specificato di volte (esempio 3: utilizzare una parte di una matrice di caratteri e ripetere un singolo carattere).

String(char* value)
(Non conforme a CLS) Inizializza la nuova istanza del valore indicato da un puntatore a una matrice di caratteri Unicode terminata da un carattere Null (U+0000 o '\0'). (Esempio 4: usare un puntatore a una matrice di caratteri).

Autorizzazione: SecurityCriticalAttribute, richiede l'attendibilità completa per il chiamante immediato. Questo membro non può essere usato da codice parzialmente attendibile o trasparente.

String(char* value, Int32 startIndex, Int32 length)
(Non conforme a CLS) Inizializza la nuova istanza del valore indicato da un puntatore a una matrice di caratteri Unicode, una posizione del carattere iniziale all'interno di tale matrice e una lunghezza. Il costruttore copia i caratteri Unicode dall'inizio value dell'indice e termina in corrispondenza dell'indice + startIndexlength startIndex - 1 (esempio 5: Creare un'istanza di una stringa da un puntatore e da un intervallo di una matrice).

Autorizzazione: SecurityCriticalAttribute, richiede l'attendibilità completa per il chiamante immediato. Questo membro non può essere usato da codice parzialmente attendibile o trasparente.

String(SByte* value)
(Non conforme a CLS) Inizializza la nuova istanza del valore indicato da un puntatore a una matrice di interi con segno a 8 bit. Si presuppone che la matrice rappresenti una stringa codificata usando la tabella codici di sistema corrente, ovvero la codifica specificata da Encoding.Default. Il costruttore elabora i caratteri a value partire dalla posizione specificata dal puntatore fino a quando non viene raggiunto un carattere Null (0x00) (esempio 6: Creare un'istanza di una stringa da un puntatore a una matrice di byte firmata).

Autorizzazione: SecurityCriticalAttribute, richiede l'attendibilità completa per il chiamante immediato. Questo membro non può essere usato da codice parzialmente attendibile o trasparente.

String(SByte* value, Int32 startIndex, Int32 length)
(Non conforme a CLS) Inizializza la nuova istanza del valore indicato da un puntatore a una matrice di interi con segno a 8 bit, una posizione iniziale all'interno di tale matrice e una lunghezza. Si presuppone che la matrice rappresenti una stringa codificata usando la tabella codici di sistema corrente, ovvero la codifica specificata da Encoding.Default. Il costruttore elabora i caratteri dal valore a partire da startIndex e termina startIndexlength + con - 1 (esempio 6: Creare un'istanza di una stringa da un puntatore a una matrice di byte firmata).

Autorizzazione: SecurityCriticalAttribute, richiede l'attendibilità completa per il chiamante immediato. Questo membro non può essere usato da codice parzialmente attendibile o trasparente.

String(SByte* value, Int32 startIndex, Int32 length, Encoding enc)
(Non conforme a CLS) Inizializza la nuova istanza del valore indicato da un puntatore a una matrice di interi con segno a 8 bit, una posizione iniziale all'interno di tale matrice, una lunghezza e un Encoding oggetto .

Autorizzazione: SecurityCriticalAttribute, richiede l'attendibilità completa per il chiamante immediato. Questo membro non può essere usato da codice parzialmente attendibile o trasparente.

Parametri

Di seguito è riportato un elenco completo dei parametri usati dai String costruttori che non includono un parametro puntatore. Per i parametri usati da ogni overload, vedere la sintassi di overload precedente.

Di seguito è riportato un elenco completo dei parametri usati dai String costruttori che includono un parametro puntatore. Per i parametri usati da ogni overload, vedere la sintassi di overload precedente.

Eccezioni

Ecco un elenco di eccezioni generate dai costruttori che non includono parametri puntatore.

Ecco un elenco di eccezioni generate dai costruttori che includono parametri puntatore.

Quale metodo chiamare?

Creare stringhe

La tecnica più comunemente usata per la creazione di stringhe a livello di codice è un'assegnazione semplice, come illustrato nell'esempio 1. La String classe include anche quattro tipi di overload del costruttore che consentono di creare stringhe dai valori seguenti:

• Da una matrice di caratteri (matrice di caratteri con codifica UTF-16). È possibile creare un nuovo String oggetto dai caratteri nell'intera matrice o in una parte di esso. Il String(Char[]) costruttore copia tutti i caratteri nella matrice nella nuova stringa. Il String(Char[], Int32, Int32) costruttore copia i caratteri dall'indice all'indice + startIndex startIndexlength - 1 alla nuova stringa. Se length è zero, il valore della nuova stringa è String.Empty.

  Se il codice crea ripetutamente istanze di stringhe con lo stesso valore, è possibile migliorare le prestazioni dell'applicazione usando un mezzo alternativo per la creazione di stringhe. Per altre informazioni, vedere Gestire stringhe ripetitive.

• Da un singolo carattere duplicato zero, uno o più volte, usando il String(Char, Int32) costruttore . Se count è zero, il valore della nuova stringa è String.Empty.

• Da un puntatore a una matrice di caratteri con terminazione Null usando il String(Char*) costruttore o String(Char*, Int32, Int32) . È possibile usare l'intera matrice o un intervallo specificato per inizializzare la stringa. Il costruttore copia una sequenza di caratteri Unicode a partire dal puntatore specificato o dal puntatore specificato più startIndex e continuando fino alla fine della matrice o per i length caratteri. Se value è un puntatore Null o length è zero, il costruttore crea una stringa il cui valore è String.Empty. Se l'operazione di copia procede alla fine della matrice e la matrice non è con terminazione Null, il comportamento del costruttore dipende dal sistema. Una condizione di questo tipo può causare una violazione di accesso.

  Se la matrice contiene caratteri Null incorporati (U+0000 o '\0') e viene chiamato l'overload, l'istanza String(Char*, Int32, Int32) della stringa contiene length caratteri inclusi tutti i valori Null incorporati. Nell'esempio seguente viene illustrato cosa accade quando un puntatore a una matrice di 10 elementi che include due caratteri Null viene passato al String(Char*, Int32, Int32) metodo . Poiché l'indirizzo è l'inizio della matrice e tutti gli elementi della matrice devono essere aggiunti alla stringa, il costruttore crea un'istanza di una stringa con dieci caratteri, inclusi due valori Null incorporati. D'altra parte, se la stessa matrice viene passata al String(Char*) costruttore, il risultato è una stringa di quattro caratteri che non include il primo carattere 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
  

  La matrice deve contenere caratteri Unicode. In C++, ciò significa che la matrice di caratteri deve essere definita come tipo gestito [] o come tipo non gestitoCharwchar_t[].

  Se viene chiamato l'overload String(Char*) e la matrice non è con terminazione Null o se l'overload String(Char*, Int32, Int32) viene chiamato e startIndex + length-1 include un intervallo esterno alla memoria allocata per la sequenza di caratteri, il comportamento del costruttore dipende dal sistema e può verificarsi una violazione di accesso.

• Da un puntatore a una matrice di byte firmata. È possibile usare l'intera matrice o un intervallo specificato per inizializzare la stringa. La sequenza di byte può essere interpretata usando la codifica della tabella codici predefinita oppure è possibile specificare una codifica nella chiamata al costruttore. Se il costruttore tenta di creare un'istanza di una stringa da un'intera matrice che non è con terminazione Null o se l'intervallo della matrice da value + startIndex a + value + startIndexlength -1 è esterno alla memoria allocata per la matrice, il comportamento di questo costruttore è dipendente dal sistema e può verificarsi una violazione di accesso.

  I tre costruttori che includono una matrice di byte firmata come parametro sono progettati principalmente per convertire una matrice C++ char in una stringa, come illustrato in questo esempio:

  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
  

  Se la matrice contiene caratteri Null ('\0') o byte il cui valore è 0 e viene chiamato l'overload, l'istanza String(SByte*, Int32, Int32) della stringa contiene length caratteri inclusi tutti i valori Null incorporati. Nell'esempio seguente viene illustrato cosa accade quando un puntatore a una matrice di 10 elementi che include due caratteri Null viene passato al String(SByte*, Int32, Int32) metodo . Poiché l'indirizzo è l'inizio della matrice e tutti gli elementi della matrice devono essere aggiunti alla stringa, il costruttore crea un'istanza di una stringa con dieci caratteri, inclusi due valori Null incorporati. D'altra parte, se la stessa matrice viene passata al String(SByte*) costruttore, il risultato è una stringa di quattro caratteri che non include il primo carattere 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
  

  Poiché i String(SByte*) costruttori e String(SByte*, Int32, Int32) interpretano value usando la tabella codici ANSI predefinita, la chiamata a questi costruttori con matrici di byte identiche può creare stringhe con valori diversi in sistemi diversi.

Gestire stringhe ripetitive

Le app che analizzano o decodificano flussi di testo spesso usano il String(Char[], Int32, Int32) costruttore o il StringBuilder.Append(Char[], Int32, Int32) metodo per convertire sequenze di caratteri in una stringa. La creazione ripetuta di nuove stringhe con lo stesso valore anziché creare e riutilizzare una stringa comporta lo spreco di memoria. Se è probabile che si crei ripetutamente lo stesso valore stringa chiamando il String(Char[], Int32, Int32) costruttore, anche se non si conosce in anticipo quali valori stringa identici potrebbero essere, è possibile usare invece una tabella di ricerca.

Si supponga, ad esempio, di leggere e analizzare un flusso di caratteri da un file che contiene tag e attributi XML. Quando si analizza il flusso, si rilevano ripetutamente determinati token, ovvero sequenze di caratteri che hanno un significato simbolico. È probabile che i token equivalenti alle stringhe "0", "1", "true" e "false" si verifichino spesso in un flusso XML.

Anziché convertire ogni token in una nuova stringa, è possibile creare un System.Xml.NameTable oggetto per contenere stringhe che si verificano comunemente. L'oggetto NameTable migliora le prestazioni, perché recupera stringhe archiviate senza allocare memoria temporanea. Quando si rileva un token, usare il NameTable.Get(Char[], Int32, Int32) metodo per recuperare il token dalla tabella. Se il token esiste, il metodo restituisce la stringa corrispondente. Se il token non esiste, usare il NameTable.Add(Char[], Int32, Int32) metodo per inserire il token nella tabella e ottenere la stringa corrispondente.

Esempio 1: Usare l'assegnazione di stringhe

Nell'esempio seguente viene creata una nuova stringa assegnando un valore letterale stringa. Crea una seconda stringa assegnando il valore della prima stringa. Questi sono i due modi più comuni per creare un'istanza di un nuovo String oggetto.

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.

Esempio 2: Usare una matrice di caratteri

Nell'esempio seguente viene illustrato come creare un nuovo String oggetto da una matrice di caratteri.

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

Esempio 3: Usare una parte di una matrice di caratteri e ripetere un singolo carattere

Nell'esempio seguente viene illustrato come creare un nuovo String oggetto da una parte di una matrice di caratteri e come creare un nuovo String oggetto contenente più occorrenze di un singolo carattere.

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

Esempio 4: Usare un puntatore a una matrice di caratteri

Nell'esempio seguente viene illustrato come creare un nuovo String oggetto da un puntatore a una matrice di caratteri. L'esempio C# deve essere compilato usando l'opzione del /unsafe compilatore.

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!

Esempio 5: Creare un'istanza di una stringa da un puntatore e un intervallo di una matrice

Nell'esempio seguente vengono esaminati gli elementi di una matrice di caratteri per un punto o un punto esclamativo. Se ne viene trovata una, crea un'istanza di una stringa dai caratteri nella matrice che precede il simbolo di punteggiatura. In caso contrario, crea un'istanza di una stringa con l'intero contenuto della matrice. L'esempio C# deve essere compilato usando l'opzione del /unsafe compilatore.

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

Esempio 6: Creare un'istanza di una stringa da un puntatore a una matrice di byte firmata

Nell'esempio seguente viene illustrato come creare un'istanza della String classe con il String(SByte*) costruttore .

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