Konstruktor System.String

Artikel
01/31/2024

Artikel ini menyediakan keterangan tambahan untuk dokumentasi referensi untuk API ini.

Sintaks konstruktor yang kelebihan beban

Konstruktor string termasuk dalam dua kategori: yang tanpa parameter pointer, dan yang memiliki parameter pointer. Konstruktor yang menggunakan pointer tidak sesuai dengan CLS. Selain itu, Visual Basic tidak mendukung penggunaan pointer, dan C# memerlukan kode yang menggunakan pointer untuk berjalan dalam konteks yang tidak aman. Untuk informasi selengkapnya, lihat tidak aman.

Untuk panduan tambahan tentang memilih kelebihan beban, lihat Metode mana yang harus saya panggil?.

String(Char[] value)
Menginisialisasi instans baru ke nilai yang ditunjukkan oleh array karakter Unicode. Konstruktor ini menyalin karakter Unicode (Contoh 2: Gunakan array karakter).

String(Char[] value, Int32 startIndex, Int32 length)
Menginisialisasi instans baru ke nilai yang ditunjukkan oleh array karakter Unicode, posisi karakter awal dalam array tersebut, dan panjangnya (Contoh 3: Gunakan sebagian array karakter dan ulangi satu karakter).

String(Char c, Int32 count)
Menginisialisasi instans baru ke nilai yang ditunjukkan oleh karakter Unicode tertentu yang mengulangi beberapa kali tertentu (Contoh 3: Gunakan sebagian array karakter dan mengulangi satu karakter).

String(char* value)
(Tidak sesuai dengan CLS) Menginisialisasi instans baru ke nilai yang ditunjukkan oleh penunjuk ke array karakter Unicode yang dihentikan oleh karakter null (U+0000 atau '\0'). (Contoh 4: Gunakan penunjuk ke array karakter).

Izin: SecurityCriticalAttribute, memerlukan kepercayaan penuh untuk pemanggil segera. Anggota ini tidak dapat digunakan oleh kode tepercaya atau transparan sebagian.

String(char* value, Int32 startIndex, Int32 length)
(Tidak sesuai dengan CLS) Menginisialisasi instans baru ke nilai yang ditunjukkan oleh penunjuk ke array karakter Unicode, posisi karakter awal dalam array tersebut, dan panjangnya. Konstruktor menyalin karakter Unicode dari value mulai dari indeks startIndex dan berakhir pada indeks startIndexlength + - 1 (Contoh 5: Membuat instans string dari penunjuk dan rentang array).

Izin: SecurityCriticalAttribute, memerlukan kepercayaan penuh untuk pemanggil segera. Anggota ini tidak dapat digunakan oleh kode tepercaya atau transparan sebagian.

String(SByte* value)
(Tidak sesuai dengan CLS) Menginisialisasi instans baru ke nilai yang ditunjukkan oleh penunjuk ke array bilangan bulat bertanda tangan 8-bit. Array diasumsikan mewakili string yang dikodekan menggunakan halaman kode sistem saat ini (yaitu, pengodean yang ditentukan oleh Encoding.Default). Konstruktor memproses karakter dari value mulai dari lokasi yang ditentukan oleh penunjuk hingga karakter null (0x00) tercapai (Contoh 6: Membuat string dari penunjuk ke array byte yang ditandatangani).

Izin: SecurityCriticalAttribute, memerlukan kepercayaan penuh untuk pemanggil segera. Anggota ini tidak dapat digunakan oleh kode tepercaya atau transparan sebagian.

String(SByte* value, Int32 startIndex, Int32 length)
(Tidak sesuai dengan CLS) Menginisialisasi instans baru ke nilai yang ditunjukkan oleh penunjuk ke array bilangan bulat bertanda tangan 8-bit, posisi awal dalam array tersebut, dan panjangnya. Array diasumsikan mewakili string yang dikodekan menggunakan halaman kode sistem saat ini (yaitu, pengodean yang ditentukan oleh Encoding.Default). Konstruktor memproses karakter dari nilai mulai dari dan berakhir pada startIndexlength + - 1 (Contoh 6: Membuat instans string dari penunjuk ke array byte yang ditandatangani).startIndex

Izin: SecurityCriticalAttribute, memerlukan kepercayaan penuh untuk pemanggil segera. Anggota ini tidak dapat digunakan oleh kode tepercaya atau transparan sebagian.

String(SByte* value, Int32 startIndex, Int32 length, Encoding enc)
(Tidak sesuai dengan CLS) Menginisialisasi instans baru ke nilai yang ditunjukkan oleh penunjuk ke array bilangan bulat bertanda tangan 8-bit, posisi awal dalam array tersebut, panjang, dan Encoding objek.

Izin: SecurityCriticalAttribute, memerlukan kepercayaan penuh untuk pemanggil segera. Anggota ini tidak dapat digunakan oleh kode tepercaya atau transparan sebagian.

Parameter

Berikut adalah daftar lengkap parameter yang digunakan oleh String konstruktor yang tidak menyertakan parameter pointer. Untuk parameter yang digunakan oleh setiap kelebihan beban, lihat sintaks kelebihan beban di atas.

Parameter	Jenis	Deskripsi
`value`	Char[]	Array karakter Unicode.
`c`	Char	Karakter Unicode.
`startIndex`	Int32	Posisi awal dalam `value` karakter pertama dalam string baru. Nilai default: 0
`length`	Int32	Jumlah karakter untuk `value` disertakan dalam string baru. Nilai default: Array.Length
`count`	Int32	Berapa kali karakter `c` diulang dalam string baru. Jika `count` nol, nilai objek baru adalah String.Empty.

Berikut adalah daftar lengkap parameter yang digunakan oleh String konstruktor yang menyertakan parameter pointer. Untuk parameter yang digunakan oleh setiap kelebihan beban, lihat sintaks kelebihan beban di atas.

Parameter	Jenis	Deskripsi
`value`	Char* -atau- SByte*	Penunjuk ke array karakter Unicode yang dihentikan null atau array bilangan bulat bertanda tangan 8-bit. Jika `value` adalah `null` atau array kosong, nilai string baru adalah String.Empty.
`startIndex`	Int32	Indeks elemen array yang menentukan karakter pertama dalam string baru. Nilai default: 0
`length`	Int32	Jumlah elemen array yang akan digunakan untuk membuat string baru. Jika panjangnya nol, konstruktor membuat string yang nilainya adalah String.Empty. Nilai default: Array.Length
`enc`	Encoding	Objek yang menentukan bagaimana array dikodekan `value` . Nilai default: Encoding.Default, atau halaman kode ANSI sistem saat ini

Pengecualian

Berikut adalah daftar pengecualian yang dilemparkan oleh konstruktor yang tidak menyertakan parameter pointer.

Pengecualian	Kondisi	Dilemparkan oleh
ArgumentNullException	`value` adalah `null`.	String(Char[], Int32, Int32)
ArgumentOutOfRangeException	`startIndex`, `length`, atau `count` kurang dari nol. -atau- Jumlah `startIndex` dan `length` lebih besar dari jumlah elemen dalam `value`. -atau- `count` kurang dari nol.	String(Char, Int32) String(Char[], Int32, Int32)

Berikut adalah daftar pengecualian yang dilemparkan oleh konstruktor yang menyertakan parameter pointer.

Pengecualian	Kondisi	Dilemparkan oleh
ArgumentException	`value` menentukan array yang berisi karakter Unicode yang tidak valid. -atau- `value` atau `value` + `startIndex` menentukan alamat yang kurang dari 64K. -atau- Instans baru String tidak dapat diinisialisasi dari `value` array byte karena `value` tidak menggunakan pengodean halaman kode default.	Semua konstruktor dengan pointer.
ArgumentNullException	`value` adalah null.	String(SByte) String(SByte, Int32, Int32) String(SByte*, Int32, Int32, Encoding)
ArgumentOutOfRangeException	Proses saat ini tidak memiliki akses baca ke semua karakter yang ditangani. -atau- `startIndex` atau `length` kurang dari nol, `value` + `startIndex` menyebabkan luapan pointer, atau proses saat ini tidak memiliki akses baca ke semua karakter yang ditangani. -atau- Panjang string baru terlalu besar untuk dialokasikan.	Semua konstruktor dengan pointer.
AccessViolationException	`value`, atau `value` + + `startIndexlength` - 1, menentukan alamat yang tidak valid.	String(SByte) String(SByte, Int32, Int32) String(SByte*, Int32, Int32, Encoding)

Metode mana yang saya panggil?

Untuk	Memanggil atau menggunakan
Buat string.	Penugasan dari string literal atau string yang ada (Contoh 1: Gunakan penetapan string)
Buat string dari seluruh array karakter.	String(Char[]) (Contoh 2: Gunakan array karakter)
Buat string dari bagian array karakter.	String(Char[], Int32, Int32) (Contoh 3: Gunakan sebagian array karakter dan ulangi satu karakter)
Buat string yang mengulangi karakter yang sama beberapa kali.	String(Char, Int32) (Contoh 3: Gunakan sebagian array karakter dan ulangi satu karakter)
Buat string dari penunjuk ke array Karakter Unicode atau lebar.	String(Char*)
Buat string dari bagian Array karakter Unicode atau wide dengan menggunakan pointer-nya.	String(Char*, Int32, Int32)
Buat string dari array C++ `char` .	String(SByte), String(SByte, Int32, Int32) -atau- String(SByte*, Int32, Int32, Encoding)
Buat string dari karakter ASCII.	ASCIIEncoding.GetString

Membuat string

Teknik yang paling umum digunakan untuk membuat string secara terprogram adalah penugasan sederhana, seperti yang diilustrasikan dalam Contoh 1. Kelas ini String juga menyertakan empat jenis kelebihan beban konstruktor yang memungkinkan Anda membuat string dari nilai berikut:

Dari array karakter (array karakter yang dikodekan UTF-16). Anda dapat membuat objek baru String dari karakter di seluruh array atau sebagiannya. String(Char[]) Konstruktor menyalin semua karakter dalam array ke string baru. String(Char[], Int32, Int32) Konstruktor menyalin karakter dari indeks ke indeks + startIndex startIndexlength - 1 ke string baru. Jika length nol, nilai string baru adalah String.Empty.

Jika kode Anda berulang kali membuat string yang memiliki nilai yang sama, Anda dapat meningkatkan performa aplikasi dengan menggunakan cara alternatif untuk membuat string. Untuk informasi selengkapnya, lihat Menangani string berulang.
Dari satu karakter yang diduplikasi nol, satu, atau beberapa kali, dengan menggunakan String(Char, Int32) konstruktor. Jika count nol, nilai string baru adalah String.Empty.
Dari penunjuk ke array karakter yang dihentikan null, dengan menggunakan String(Char*) konstruktor atau String(Char*, Int32, Int32) . Seluruh array atau rentang tertentu dapat digunakan untuk menginisialisasi string. Konstruktor menyalin urutan karakter Unicode mulai dari penunjuk yang ditentukan atau dari penunjuk yang ditentukan ditambah startIndex dan melanjutkan ke akhir array atau untuk length karakter. Jika value adalah penunjuk null atau length nol, konstruktor membuat string yang nilainya adalah String.Empty. Jika operasi salin berlanjut ke akhir array dan array tidak dihentikan null, perilaku konstruktor bergantung pada sistem. Kondisi seperti itu dapat menyebabkan pelanggaran akses.

Jika array berisi karakter null yang disematkan (U+0000 atau '\0') dan String(Char*, Int32, Int32) kelebihan beban dipanggil, instans string berisi length karakter termasuk null yang disematkan. Contoh berikut menunjukkan apa yang terjadi ketika penunjuk ke array 10 elemen yang menyertakan dua karakter null diteruskan ke String(Char*, Int32, Int32) metode . Karena alamat adalah awal array dan semua elemen dalam array akan ditambahkan ke string, konstruktor membuat instans string dengan sepuluh karakter, termasuk dua null yang disematkan. Di sisi lain, jika array yang sama diteruskan ke String(Char*) konstruktor, hasilnya adalah string empat karakter yang tidak menyertakan karakter null pertama.
```
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
```
Array harus berisi karakter Unicode. Di C++, ini berarti bahwa array karakter harus didefinisikan sebagai jenis [] terkelola Charatau jenis [] yang tidak dikelolawchar_t.

String(Char*) Jika kelebihan beban dipanggil dan array tidak dihentikan null, atau jika String(Char*, Int32, Int32) kelebihan beban dipanggil dan startIndex + length-1 menyertakan rentang yang berada di luar memori yang dialokasikan untuk urutan karakter, perilaku konstruktor bergantung pada sistem, dan pelanggaran akses dapat terjadi.
Dari penunjuk ke array byte yang ditandatangani. Seluruh array atau rentang tertentu dapat digunakan untuk menginisialisasi string. Urutan byte dapat ditafsirkan dengan menggunakan pengodean halaman kode default, atau pengodean dapat ditentukan dalam panggilan konstruktor. Jika konstruktor mencoba membuat instans string dari seluruh array yang tidak dihentikan null, atau jika rentang array dari value + startIndex ke + value + startIndexlength -1 berada di luar memori yang dialokasikan untuk array, perilaku konstruktor ini bergantung pada sistem, dan pelanggaran akses dapat terjadi.

Tiga konstruktor yang menyertakan array byte yang ditandatangani sebagai parameter dirancang terutama untuk mengonversi array C++ char menjadi string, seperti yang ditunjukkan dalam contoh ini:
```
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
```
Jika array berisi karakter null ('\0') atau byte yang nilainya 0 dan String(SByte*, Int32, Int32) kelebihan beban dipanggil, instans string berisi length karakter termasuk null yang disematkan. Contoh berikut menunjukkan apa yang terjadi ketika penunjuk ke array 10 elemen yang menyertakan dua karakter null diteruskan ke String(SByte*, Int32, Int32) metode . Karena alamat adalah awal array dan semua elemen dalam array akan ditambahkan ke string, konstruktor membuat instans string dengan sepuluh karakter, termasuk dua null yang disematkan. Di sisi lain, jika array yang sama diteruskan ke String(SByte*) konstruktor, hasilnya adalah string empat karakter yang tidak menyertakan karakter null pertama.
```
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*) Karena konstruktor dan String(SByte*, Int32, Int32) menafsirkan value dengan menggunakan halaman kode ANSI default, memanggil konstruktor ini dengan array byte yang identik dapat membuat string yang memiliki nilai berbeda pada sistem yang berbeda.

Menangani string berulang

Aplikasi yang mengurai atau mendekode aliran teks sering menggunakan String(Char[], Int32, Int32) konstruktor atau StringBuilder.Append(Char[], Int32, Int32) metode untuk mengonversi urutan karakter menjadi string. Berulang kali membuat string baru dengan nilai yang sama alih-alih membuat dan menggunakan kembali satu string membuang memori. Jika Anda cenderung membuat nilai string yang sama berulang kali dengan memanggil String(Char[], Int32, Int32) konstruktor, bahkan jika Anda tidak tahu terlebih dahulu nilai string yang identik tersebut, Anda dapat menggunakan tabel pencarian sebagai gantinya.

Misalnya, Anda membaca dan mengurai aliran karakter dari file yang berisi tag dan atribut XML. Saat mengurai aliran, Anda berulang kali menemukan token tertentu (yaitu, urutan karakter yang memiliki arti simbolis). Token yang setara dengan string "0", "1", "true", dan "false" kemungkinan sering terjadi dalam aliran XML.

Alih-alih mengonversi setiap token menjadi string baru, Anda dapat membuat System.Xml.NameTable objek untuk menyimpan string yang umum terjadi. Objek NameTable meningkatkan performa, karena mengambil string yang disimpan tanpa mengalokasikan memori sementara. Saat Anda menemukan token, gunakan NameTable.Get(Char[], Int32, Int32) metode untuk mengambil token dari tabel. Jika token ada, metode mengembalikan string yang sesuai. Jika token tidak ada, gunakan NameTable.Add(Char[], Int32, Int32) metode untuk menyisipkan token ke dalam tabel dan untuk mendapatkan string yang sesuai.

Contoh 1: Menggunakan penetapan string

Contoh berikut membuat string baru dengan menetapkan string literal. Ini membuat string kedua dengan menetapkan nilai string pertama ke dalamnya. Ini adalah dua cara paling umum untuk membuat instans objek baru String .

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.

Contoh 2: Menggunakan array karakter

Contoh berikut menunjukkan cara membuat objek baru String dari array karakter.

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

Contoh 3: Menggunakan sebagian array karakter dan mengulangi satu karakter

Contoh berikut menunjukkan cara membuat objek baru String dari sebagian array karakter, dan cara membuat objek baru String yang berisi beberapa kemunculan satu karakter.

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

Contoh 4: Menggunakan penunjuk ke array karakter

Contoh berikut menunjukkan cara membuat objek baru String dari penunjuk ke array karakter. Contoh C# harus dikompilasi dengan menggunakan sakelar /unsafe pengkompilasi.

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!

Contoh 5: Membuat instans string dari penunjuk dan rentang array

Contoh berikut memeriksa elemen array karakter untuk titik atau tanda seru. Jika ditemukan, itu membuat instans string dari karakter dalam array yang mendahului simbol tanda baca. Jika tidak, ini membuat instans string dengan seluruh konten array. Contoh C# harus dikompilasi menggunakan sakelar /unsafe pengkompilasi.

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

Contoh 6: Membuat instans string dari penunjuk ke array byte yang ditandatangani

Contoh berikut menunjukkan bagaimana Anda dapat membuat instans String kelas dengan String(SByte*) konstruktor.

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