System.String oluşturucu

Bu makale, bu API'nin başvuru belgelerine ek açıklamalar sağlar.

Aşırı yüklenmiş oluşturucu sözdizimi

Dize oluşturucuları iki kategoriye ayrılır: işaretçi parametresi olmayanlar ve işaretçi parametreleri olanlar. İşaretçi kullanan oluşturucular CLS uyumlu değildir. Ayrıca, Visual Basic işaretçi kullanımını desteklemez ve C# güvenli olmayan bir bağlamda çalıştırmak için işaretçileri kullanan kod gerektirir. Daha fazla bilgi için bkz . güvenli değil.

Aşırı yükleme seçme hakkında ek yönergeler için bkz . Hangi yöntemi çağırmalıyım?.

String(Char[] value)
Yeni örneği bir Unicode karakterleri dizisiyle gösterilen değere başlatır. Bu oluşturucu Unicode karakterlerini kopyalar (Örnek 2: Karakter dizisi kullanma).

String(Char[] value, Int32 startIndex, Int32 length)
Yeni örneği bir Unicode karakter dizisi, bu dizi içinde bir başlangıç karakteri konumu ve bir uzunluk ile belirtilen değere başlatır (Örnek 3: Karakter dizisinin bir bölümünü kullanma ve tek bir karakteri yineleme).

String(Char c, Int32 count)
Yeni örneği belirtilen sayıda yinelenen belirtilen Unicode karakteriyle belirtilen değere başlatır (Örnek 3: Karakter dizisinin bir bölümünü kullanma ve tek bir karakteri yineleme).

String(char* value)
(CLS uyumlu değil) Yeni örneği, null karakter (U+0000 veya '\0') ile sonlandırılan Unicode karakter dizisi işaretçisi tarafından gösterilen değere başlatır. (Örnek 4: Karakter dizisi işaretçisi kullanma).

İzin: SecurityCriticalAttribute, hemen çağıran için tam güven gerektirir. Bu üye kısmen güvenilen veya saydam kod tarafından kullanılamaz.

String(char* value, Int32 startIndex, Int32 length)
(CLS uyumlu değil) Yeni örneği, bir Unicode karakter dizisinin işaretçisi, bu dizi içinde bir başlangıç karakteri konumu ve bir uzunluk ile gösterilen değere başlatır. Oluşturucu, Unicode karakterlerini dizinden value başlayıp dizin startIndex - 1 ile biten startIndex + length şekilde kopyalar (Örnek 5: bir işaretçiden ve dizi aralığından bir dize örneği oluşturma).

İzin: SecurityCriticalAttribute, hemen çağıran için tam güven gerektirir. Bu üye kısmen güvenilen veya saydam kod tarafından kullanılamaz.

String(SByte* value)
(CLS uyumlu değil) Yeni örneği, 8 bit imzalı tamsayılar dizisinin işaretçisi tarafından gösterilen değere başlatır. Dizinin geçerli sistem kodu sayfası (yani tarafından Encoding.Defaultbelirtilen kodlama) kullanılarak kodlanmış bir dizeyi temsil ettiği varsayılır. Oluşturucu, işaretçi tarafından belirtilen konumdan value başlayıp null karaktere (0x00) ulaşılana kadar karakterleri işler (Örnek 6: İşaretçiden imzalı bayt dizisine bir dize örneği oluşturma).

İzin: SecurityCriticalAttribute, hemen çağıran için tam güven gerektirir. Bu üye kısmen güvenilen veya saydam kod tarafından kullanılamaz.

String(SByte* value, Int32 startIndex, Int32 length)
(CLS uyumlu değil) Yeni örneği, 8 bit imzalı tamsayılardan oluşan bir dizi, bu dizi içinde başlangıç konumu ve bir uzunluk işaretçisi tarafından belirtilen değere başlatır. Dizinin geçerli sistem kodu sayfası (yani tarafından Encoding.Defaultbelirtilen kodlama) kullanılarak kodlanmış bir dizeyi temsil ettiği varsayılır. Oluşturucu, - 1 ile başlayan startIndex ve biten startIndexlength + değerden karakterleri işler (Örnek 6: İşaretçiden imzalı bayt dizisine bir dize örneği oluşturma).

İzin: SecurityCriticalAttribute, hemen çağıran için tam güven gerektirir. Bu üye kısmen güvenilen veya saydam kod tarafından kullanılamaz.

String(SByte* value, Int32 startIndex, Int32 length, Encoding enc)
(CLS uyumlu değil) Yeni örneği, 8 bit imzalı tamsayılar dizisi, bu dizi içinde başlangıç konumu, uzunluk ve Encoding nesne işaretçisi tarafından gösterilen değere başlatır.

İzin: SecurityCriticalAttribute, hemen çağıran için tam güven gerektirir. Bu üye kısmen güvenilen veya saydam kod tarafından kullanılamaz.

Parametreler

Burada, işaretçi parametresi içermeyen oluşturucular tarafından String kullanılan parametrelerin tam listesi yer alır. Her aşırı yükleme tarafından kullanılan parametreler için, yukarıdaki aşırı yükleme sözdizimine bakın.

Burada, işaretçi parametresi içeren oluşturucular tarafından String kullanılan parametrelerin tam listesi yer alır. Her aşırı yükleme tarafından kullanılan parametreler için, yukarıdaki aşırı yükleme sözdizimine bakın.

Özel durumlar

burada, işaretçi parametrelerini içermeyen oluşturucular tarafından atılan özel durumların listesi yer alır.

burada işaretçi parametreleri içeren oluşturucular tarafından atılan özel durumların listesi yer alır.

Hangi yöntemi çağırmalıyım?

Dize oluşturma

Örnek 1'de gösterildiği gibi, program aracılığıyla dize oluşturmak için en yaygın kullanılan teknik basit atamadır. sınıfı String ayrıca aşağıdaki değerlerden dizeler oluşturmanıza olanak sağlayan dört tür oluşturucu aşırı yüklemesi içerir:

• Bir karakter dizisinden (UTF-16 ile kodlanmış karakter dizisi). Dizinin tamamında veya bir bölümünde yer alan karakterlerden yeni String bir nesne oluşturabilirsiniz. Oluşturucu, String(Char[]) dizideki tüm karakterleri yeni dizeye kopyalar. Oluşturucu, String(Char[], Int32, Int32) dizinden dizine + startIndex startIndexlength - 1 karakterlerini yeni dizeye kopyalar. Sıfır ise length , yeni dizenin değeri olur String.Empty.

  Kodunuz aynı değere sahip dizeleri tekrar tekrar oluşturuyorsa, dize oluşturmanın alternatif bir yöntemini kullanarak uygulama performansını geliştirebilirsiniz. Daha fazla bilgi için bkz . Yinelenen dizeleri işleme.

• Oluşturucuyu kullanarak sıfır, bir veya daha fazla kez çoğaltılan tek bir karakterden String(Char, Int32) . Sıfır ise count , yeni dizenin değeri olur String.Empty.

• veya String(Char*, Int32, Int32) oluşturucuyu kullanarak bir işaretçiden null ile sonlandırılan bir karakter dizisineString(Char*). Dizeyi başlatmak için tüm dizi ya da belirtilen bir aralık kullanılabilir. Oluşturucu, belirtilen işaretçiden veya belirtilen işaretçi artıdan startIndex başlayıp dizinin sonuna veya karakterler için length devam eden bir Unicode karakter dizisi kopyalar. Null işaretçi veya length sıfır isevalue, oluşturucu değeri String.Emptyolan bir dize oluşturur. Kopyalama işlemi dizinin sonuna doğru ilerler ve dizi null olarak sonlandırılmazsa, oluşturucu davranışı sisteme bağlıdır. Böyle bir koşul erişim ihlaline neden olabilir.

  Dizi eklenmiş null karakterler içeriyorsa (U+0000 veya '\0') ve String(Char*, Int32, Int32) aşırı yükleme çağrılırsa, dize örneği eklenmiş null değerleri içeren karakterler içerir length . Aşağıdaki örnekte, yöntemine iki null karakter içeren 10 öğeden oluşan bir diziye String(Char*, Int32, Int32) işaretçi geçirildiğinde ne olacağı gösterilmektedir. Adres dizinin başlangıcı olduğundan ve dizideki tüm öğeler dizeye eklendiğinden, oluşturucu iki katıştırılmış null dahil olmak üzere on karakterli bir dize örneği oluşturur. Öte yandan, aynı dizi oluşturucuya String(Char*) geçirilirse, sonuç ilk null karakteri içermeyen dört karakterli bir dizedir.

  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
  

  Dizi Unicode karakterler içermelidir. C++ dilinde bu, karakter dizisinin yönetilen Char[] türü veya yönetilmeyenwchar_t[] türü olarak tanımlanması gerektiği anlamına gelir.

  String(Char*) Aşırı yükleme çağrılır ve dizi null sonlandırılmazsa veya aşırı yükleme çağrılırsa String(Char*, Int32, Int32) ve startIndex + length-1 karakter dizisi için ayrılan belleğin dışında bir aralık içeriyorsa, oluşturucunun davranışı sisteme bağımlıdır ve erişim ihlali oluşabilir.

• İşaretçiden imzalı bayt dizisine. Dizeyi başlatmak için tüm dizi ya da belirtilen bir aralık kullanılabilir. Bayt dizisi varsayılan kod sayfası kodlaması kullanılarak yorumlanabilir veya oluşturucu çağrısında bir kodlama belirtilebilir. Oluşturucu null sonlandırılmamış bir dizinin tamamından bir dize örneği oluşturmaya çalışırsa veya -1 dizinin aralığı valuestartIndexstartIndexlength + value + + dizi için ayrılan belleğin dışındaysa, bu oluşturucunun davranışı sisteme bağımlıdır ve erişim ihlali oluşabilir.

  İmzalı bayt dizisini parametre olarak içeren üç oluşturucu, bu örnekte gösterildiği gibi öncelikle bir C++ char dizisini dizeye dönüştürmek için tasarlanmıştır:

  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
  

  Dizide değeri 0 olan null karakterler ('\0') veya baytlar varsa ve String(SByte*, Int32, Int32) aşırı yükleme çağrılırsa, dize örneği eklenmiş null değerleri içeren karakterler içerir length . Aşağıdaki örnekte, yöntemine iki null karakter içeren 10 öğeden oluşan bir diziye String(SByte*, Int32, Int32) işaretçi geçirildiğinde ne olacağı gösterilmektedir. Adres dizinin başlangıcı olduğundan ve dizideki tüm öğeler dizeye eklendiğinden, oluşturucu iki katıştırılmış null dahil olmak üzere on karakterli bir dize örneği oluşturur. Öte yandan, aynı dizi oluşturucuya String(SByte*) geçirilirse, sonuç ilk null karakteri içermeyen dört karakterli bir dizedir.

  using System;
  
  public class Example5
  {
     public unsafe static void Main()
     {
        sbyte[] bytes = { 0x61, 0x62, 0x063, 0x064, 0x00, 0x41, 0x42, 0x43, 0x44, 0x00 };
        
        string s = null;
        fixed (sbyte* bytePtr = bytes) {
           s = new string(bytePtr, 0, bytes.Length);
        }
        
        foreach (var ch in s)
           Console.Write($"{(ushort)ch:X4} ");
        
        Console.WriteLine();    
  
        fixed(sbyte* bytePtr = bytes) {
           s = new string(bytePtr);         
        }
        
        foreach (var ch in s)
           Console.Write($"{(ushort)ch:X4} ");
        Console.WriteLine();    
     }
  }
  // The example displays the following output:
  //       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
  //       0061 0062 0063 0064
  

  #nowarn "9"
  open System
  
  let bytes = 
      [| 0x61y; 0x62y; 0x063y; 0x064y; 0x00y; 0x41y; 0x42y; 0x43y; 0x44y; 0x00y |]
  
  let s =
      use bytePtr = fixed bytes
      String(bytePtr, 0, bytes.Length)
  
  for ch in s do
      printf $"{uint16 ch:X4} "
  printfn ""
  
  let s2 =
      use bytePtr = fixed bytes
      String bytePtr         
  
  for ch in s do
      printf $"{uint16 ch:X4} "
  printfn ""
  // The example displays the following output:
  //       0061 0062 0063 0064 0000 0041 0042 0043 0044 0000
  //       0061 0062 0063 0064
  

  String(SByte*) ve String(SByte*, Int32, Int32) oluşturucuları varsayılan ANSI kod sayfasını kullanarak yorumladığı value için, bu oluşturucuları aynı bayt dizileriyle çağırmak farklı sistemlerde farklı değerlere sahip dizeler oluşturabilir.

Yinelenen dizeleri işleme

Metin akışlarını ayrıştıran veya kodunu çözen uygulamalar genellikle karakter dizilerini dizeye dönüştürmek için oluşturucuyu veya StringBuilder.Append(Char[], Int32, Int32) yöntemini kullanırString(Char[], Int32, Int32). Bir dizeyi oluşturmak ve yeniden oluşturmak yerine aynı değere sahip yeni dizelerin tekrar tekrar oluşturulması belleği boşa harcar. Oluşturucuyu çağırarak String(Char[], Int32, Int32) aynı dize değerini tekrar tekrar oluşturma olasılığınız varsa, bu özdeş dize değerlerinin ne olabileceğini önceden bilmeseniz bile, bunun yerine bir arama tablosu kullanabilirsiniz.

Örneğin, XML etiketleri ve öznitelikleri içeren bir dosyadan bir karakter akışı okuduğunu ve ayrıştırdığını varsayalım. Akışı ayrıştırdığınızda, belirli belirteçlerle (sembolik anlamı olan karakter dizileri) tekrar tekrar karşılaşırsınız. Xml akışında "0", "1", "true" ve "false" dizelerine eşdeğer belirteçler sık sık ortaya çıkabilir.

Her belirteci yeni bir dizeye dönüştürmek yerine, sık oluşan dizeleri tutmak için bir System.Xml.NameTable nesne oluşturabilirsiniz. NameTable Nesne, geçici bellek ayırmadan depolanan dizeleri aldığından performansı artırır. Bir belirteçle karşılaştığınızda, tablodan NameTable.Get(Char[], Int32, Int32) belirteci almak için yöntemini kullanın. Belirteç varsa, yöntemi karşılık gelen dizeyi döndürür. Belirteç yoksa, belirteci tabloya eklemek ve karşılık gelen dizeyi almak için yöntemini kullanın NameTable.Add(Char[], Int32, Int32) .

Örnek 1: Dize ataması kullanma

Aşağıdaki örnek, dize değişmez değeri atayarak yeni bir dize oluşturur. İlk dizenin değerini ona atayarak ikinci bir dize oluşturur. Bunlar, yeni String bir nesnenin örneğini oluşturmanın en yaygın iki yoludır.

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.

Örnek 2: Karakter dizisi kullanma

Aşağıdaki örnekte, bir karakter dizisinden yeni String bir nesnenin nasıl oluşturulacağı gösterilmektedir.

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

Örnek 3: Karakter dizisinin bir bölümünü kullanma ve tek bir karakteri yineleme

Aşağıdaki örnekte, karakter dizisinin bir bölümünden yeni String bir nesne oluşturma ve tek bir karakterin birden çok oluşumunu içeren yeni String bir nesnenin nasıl oluşturulacağı gösterilmektedir.

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

Örnek 4: Karakter dizisi işaretçisi kullanma

Aşağıdaki örnekte, bir işaretçiden bir karakter dizisine yeni String bir nesnenin nasıl oluşturulacağı gösterilmektedir. C# örneği derleyici anahtarı kullanılarak /unsafe derlenmelidir.

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!

Örnek 5: bir işaretçiden ve dizi aralığından bir dize örneği oluşturma

Aşağıdaki örnek, bir nokta veya ünlem işareti için karakter dizisinin öğelerini inceler. Bulunursa, dizideki noktalama işaretinden önceki karakterlerden bir dize örneği oluşturur. Yoksa, dizinin tüm içeriğini içeren bir dize örneği oluşturur. C# örneği derleyici anahtarı kullanılarak /unsafe derlenmelidir.

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

Örnek 6: İşaretçiden imzalı bayt dizisine bir dize örneği oluşturma

Aşağıdaki örnek, oluşturucu ile sınıfının bir örneğini String nasıl oluşturabileceğinizi String(SByte*) gösterir.

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