Struktur System.Char

Artikel
01/08/2024

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

Struktur mewakili Char titik kode Unicode dengan menggunakan pengodean UTF-16. Nilai objek adalah Char nilai numerik 16-bit (ordinal).

Jika Anda tidak terbiasa dengan Unicode, nilai skalar, titik kode, pasangan pengganti, UTF-16, dan jenisnya Rune , lihat Pengenalan pengodean karakter di .NET.

Artikel ini memeriksa hubungan antara Char objek dan karakter dan membahas beberapa tugas umum yang dilakukan dengan Char instans. Kami menyarankan agar Anda mempertimbangkan jenisnya Rune , yang diperkenalkan di .NET Core 3.0, sebagai alternatif Char untuk melakukan beberapa tugas ini.

Objek karakter, karakter Unicode, dan string

Objek String adalah kumpulan Char struktur berurutan yang mewakili string teks. Sebagian besar karakter Unicode dapat diwakili oleh satu Char objek, tetapi karakter yang dikodekan sebagai karakter dasar, pasangan pengganti, dan/atau menggabungkan urutan karakter diwakili oleh beberapa Char objek. Untuk alasan ini, Char struktur dalam String objek tidak selalu setara dengan satu karakter Unicode.

Beberapa unit kode 16-bit digunakan untuk mewakili karakter Unicode tunggal dalam kasus berikut:

Glyph, yang mungkin terdiri dari satu karakter atau karakter dasar diikuti oleh satu atau beberapa karakter yang menggabungkan. Misalnya, karakter ä diwakili oleh Char objek yang unit kodenya adalah U+0061 diikuti oleh Char objek yang unit kodenya adalah U+0308. (Karakter ä juga dapat ditentukan oleh satu Char objek yang memiliki unit kode U+00E4.) Contoh berikut menggambarkan bahwa karakter ä terdiri dari dua Char objek.

using System;
using System.IO;

public class Example1
{
    public static void Main()
    {
        StreamWriter sw = new StreamWriter("chars1.txt");
        char[] chars = { '\u0061', '\u0308' };
        string strng = new String(chars);
        sw.WriteLine(strng);
        sw.Close();
    }
}
// The example produces the following output:
//       ä

open System
open System.IO

let sw = new StreamWriter("chars1.txt")
let chars = [| '\u0061'; '\u0308' |]
let string = String chars
sw.WriteLine string
sw.Close()

// The example produces the following output:
//       ä

Imports System.IO

Module Example2
    Public Sub Main()
        Dim sw As New StreamWriter("chars1.txt")
        Dim chars() As Char = {ChrW(&H61), ChrW(&H308)}
        Dim strng As New String(chars)
        sw.WriteLine(strng)
        sw.Close()
    End Sub
End Module
' The example produces the following output:
'       ä

Karakter di luar Unicode Basic Multilingual Plane (BMP). Unicode mendukung enam belas bidang selain BMP, yang mewakili bidang 0. Titik kode Unicode diwakili dalam UTF-32 dengan nilai 21-bit yang menyertakan bidang. Misalnya, U+1D160 mewakili karakter CATATAN MUSICAL SYMBOL EIGHTH. Karena pengodean UTF-16 hanya memiliki 16 bit, karakter di luar BMP diwakili oleh pasangan pengganti dalam UTF-16. Contoh berikut menggambarkan bahwa UTF-32 setara dengan U+1D160, karakter MUSICAL SYMBOL EIGHTH NOTE, adalah U+D834 U+DD60. U+D834 adalah pengganti tinggi; pengganti tinggi berkisar dari U+D800 hingga U+DBFF. U+DD60 adalah pengganti rendah; pengganti rendah berkisar dari U+DC00 hingga U+DFFF.

using System;
using System.IO;

public class Example3
{
    public static void Main()
    {
        StreamWriter sw = new StreamWriter(@".\chars2.txt");
        int utf32 = 0x1D160;
        string surrogate = Char.ConvertFromUtf32(utf32);
        sw.WriteLine("U+{0:X6} UTF-32 = {1} ({2}) UTF-16",
                     utf32, surrogate, ShowCodePoints(surrogate));
        sw.Close();
    }

    private static string ShowCodePoints(string value)
    {
        string retval = null;
        foreach (var ch in value)
            retval += String.Format("U+{0:X4} ", Convert.ToUInt16(ch));

        return retval.Trim();
    }
}
// The example produces the following output:
//       U+01D160 UTF-32 = ð (U+D834 U+DD60) UTF-16

open System
open System.IO

let showCodePoints (value: char seq) =
    let str =
        value
        |> Seq.map (fun ch -> $"U+{Convert.ToUInt16 ch:X4}")
        |> String.concat ""
    str.Trim()

let sw = new StreamWriter(@".\chars2.txt")
let utf32 = 0x1D160
let surrogate = Char.ConvertFromUtf32 utf32
sw.WriteLine $"U+{utf32:X6} UTF-32 = {surrogate} ({showCodePoints surrogate}) UTF-16"
sw.Close()

// The example produces the following output:
//       U+01D160 UTF-32 = ð (U+D834 U+DD60) UTF-16

Imports System.IO

Module Example4
    Public Sub Main()
        Dim sw As New StreamWriter(".\chars2.txt")
        Dim utf32 As Integer = &H1D160
        Dim surrogate As String = Char.ConvertFromUtf32(utf32)
        sw.WriteLine("U+{0:X6} UTF-32 = {1} ({2}) UTF-16",
                   utf32, surrogate, ShowCodePoints(surrogate))
        sw.Close()
    End Sub

    Private Function ShowCodePoints(value As String) As String
        Dim retval As String = Nothing
        For Each ch In value
            retval += String.Format("U+{0:X4} ", Convert.ToUInt16(ch))
        Next
        Return retval.Trim()
    End Function
End Module
' The example produces the following output:
'       U+01D160 UTF-32 = ð (U+D834 U+DD60) UTF-16

Kategori karakter dan karakter

Setiap karakter Unicode atau pasangan pengganti yang valid termasuk dalam kategori Unicode. Dalam .NET, kategori Unicode diwakili oleh anggota UnicodeCategory enumerasi dan menyertakan nilai seperti UnicodeCategory.CurrencySymbol, , UnicodeCategory.LowercaseLetterdan UnicodeCategory.SpaceSeparator, misalnya.

Untuk menentukan kategori Unicode karakter, panggil GetUnicodeCategory metode . Misalnya, contoh berikut memanggil GetUnicodeCategory untuk menampilkan kategori Unicode dari setiap karakter dalam string. Contoh bekerja dengan benar hanya jika tidak ada pasangan pengganti dalam String instans.

using System;
using System.Globalization;

class Example
{
   public static void Main()
   {
      // Define a string with a variety of character categories.
      String s = "The red car drove down the long, narrow, secluded road.";
      // Determine the category of each character.
      foreach (var ch in s)
         Console.WriteLine("'{0}': {1}", ch, Char.GetUnicodeCategory(ch));
   }
}
// The example displays the following output:
//      'T': UppercaseLetter
//      'h': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'r': LowercaseLetter
//      'e': LowercaseLetter
//      'd': LowercaseLetter
//      ' ': SpaceSeparator
//      'c': LowercaseLetter
//      'a': LowercaseLetter
//      'r': LowercaseLetter
//      ' ': SpaceSeparator
//      'd': LowercaseLetter
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'v': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'd': LowercaseLetter
//      'o': LowercaseLetter
//      'w': LowercaseLetter
//      'n': LowercaseLetter
//      ' ': SpaceSeparator
//      't': LowercaseLetter
//      'h': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'l': LowercaseLetter
//      'o': LowercaseLetter
//      'n': LowercaseLetter
//      'g': LowercaseLetter
//      ',': OtherPunctuation
//      ' ': SpaceSeparator
//      'n': LowercaseLetter
//      'a': LowercaseLetter
//      'r': LowercaseLetter
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'w': LowercaseLetter
//      ',': OtherPunctuation
//      ' ': SpaceSeparator
//      's': LowercaseLetter
//      'e': LowercaseLetter
//      'c': LowercaseLetter
//      'l': LowercaseLetter
//      'u': LowercaseLetter
//      'd': LowercaseLetter
//      'e': LowercaseLetter
//      'd': LowercaseLetter
//      ' ': SpaceSeparator
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'a': LowercaseLetter
//      'd': LowercaseLetter
//      '.': OtherPunctuation

open System

// Define a string with a variety of character categories.
let s = "The red car drove down the long, narrow, secluded road."
// Determine the category of each character.
for ch in s do
    printfn $"'{ch}': {Char.GetUnicodeCategory ch}"

// The example displays the following output:
//      'T': UppercaseLetter
//      'h': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'r': LowercaseLetter
//      'e': LowercaseLetter
//      'd': LowercaseLetter
//      ' ': SpaceSeparator
//      'c': LowercaseLetter
//      'a': LowercaseLetter
//      'r': LowercaseLetter
//      ' ': SpaceSeparator
//      'd': LowercaseLetter
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'v': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'd': LowercaseLetter
//      'o': LowercaseLetter
//      'w': LowercaseLetter
//      'n': LowercaseLetter
//      ' ': SpaceSeparator
//      't': LowercaseLetter
//      'h': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'l': LowercaseLetter
//      'o': LowercaseLetter
//      'n': LowercaseLetter
//      'g': LowercaseLetter
//      ',': OtherPunctuation
//      ' ': SpaceSeparator
//      'n': LowercaseLetter
//      'a': LowercaseLetter
//      'r': LowercaseLetter
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'w': LowercaseLetter
//      ',': OtherPunctuation
//      ' ': SpaceSeparator
//      's': LowercaseLetter
//      'e': LowercaseLetter
//      'c': LowercaseLetter
//      'l': LowercaseLetter
//      'u': LowercaseLetter
//      'd': LowercaseLetter
//      'e': LowercaseLetter
//      'd': LowercaseLetter
//      ' ': SpaceSeparator
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'a': LowercaseLetter
//      'd': LowercaseLetter
//      '.': OtherPunctuation

Imports System.Globalization

Module Example1
    Public Sub Main()
        ' Define a string with a variety of character categories.
        Dim s As String = "The car drove down the narrow, secluded road."
        ' Determine the category of each character.
        For Each ch In s
            Console.WriteLine("'{0}': {1}", ch, Char.GetUnicodeCategory(ch))
        Next
    End Sub
End Module
' The example displays the following output:
'       'T': UppercaseLetter
'       'h': LowercaseLetter
'       'e': LowercaseLetter
'       ' ': SpaceSeparator
'       'r': LowercaseLetter
'       'e': LowercaseLetter
'       'd': LowercaseLetter
'       ' ': SpaceSeparator
'       'c': LowercaseLetter
'       'a': LowercaseLetter
'       'r': LowercaseLetter
'       ' ': SpaceSeparator
'       'd': LowercaseLetter
'       'r': LowercaseLetter
'       'o': LowercaseLetter
'       'v': LowercaseLetter
'       'e': LowercaseLetter
'       ' ': SpaceSeparator
'       'd': LowercaseLetter
'       'o': LowercaseLetter
'       'w': LowercaseLetter
'       'n': LowercaseLetter
'       ' ': SpaceSeparator
'       't': LowercaseLetter
'       'h': LowercaseLetter
'       'e': LowercaseLetter
'       ' ': SpaceSeparator
'       'l': LowercaseLetter
'       'o': LowercaseLetter
'       'n': LowercaseLetter
'       'g': LowercaseLetter
'       ',': OtherPunctuation
'       ' ': SpaceSeparator
'       'n': LowercaseLetter
'       'a': LowercaseLetter
'       'r': LowercaseLetter
'       'r': LowercaseLetter
'       'o': LowercaseLetter
'       'w': LowercaseLetter
'       ',': OtherPunctuation
'       ' ': SpaceSeparator
'       's': LowercaseLetter
'       'e': LowercaseLetter
'       'c': LowercaseLetter
'       'l': LowercaseLetter
'       'u': LowercaseLetter
'       'd': LowercaseLetter
'       'e': LowercaseLetter
'       'd': LowercaseLetter
'       ' ': SpaceSeparator
'       'r': LowercaseLetter
'       'o': LowercaseLetter
'       'a': LowercaseLetter
'       'd': LowercaseLetter
'       '.': OtherPunctuation

Secara internal, untuk karakter di luar rentang ASCII (U+0000 hingga U+00FF), GetUnicodeCategory metode tergantung pada kategori Unicode yang CharUnicodeInfo dilaporkan oleh kelas. Dimulai dengan .NET Framework 4.6.2, karakter Unicode diklasifikasikan berdasarkan Standar Unicode, Versi 8.0.0. Dalam versi .NET Framework dari .NET Framework 4 hingga .NET Framework 4.6.1, mereka diklasifikasikan berdasarkan Standar Unicode, Versi 6.3.0.

Karakter dan elemen teks

Karena satu karakter dapat diwakili oleh beberapa Char objek, tidak selalu bermakna untuk bekerja dengan objek individual Char . Misalnya, contoh berikut mengonversi titik kode Unicode yang mewakili angka Aegean nol hingga 9 ke unit kode yang dikodekan UTF-16. Karena secara keliru menyamakan Char objek dengan karakter, string yang dihasilkan secara tidak akurat melaporkan bahwa string yang dihasilkan memiliki 20 karakter.

using System;

public class Example5
{
    public static void Main()
    {
        string result = String.Empty;
        for (int ctr = 0x10107; ctr <= 0x10110; ctr++)  // Range of Aegean numbers.
            result += Char.ConvertFromUtf32(ctr);

        Console.WriteLine("The string contains {0} characters.", result.Length);
    }
}
// The example displays the following output:
//     The string contains 20 characters.

open System

let result =
    [ for i in 0x10107..0x10110 do  // Range of Aegean numbers.
        Char.ConvertFromUtf32 i ]
    |> String.concat ""

printfn $"The string contains {result.Length} characters."


// The example displays the following output:
//     The string contains 20 characters.

Module Example5
    Public Sub Main()
        Dim result As String = String.Empty
        For ctr As Integer = &H10107 To &H10110     ' Range of Aegean numbers.
            result += Char.ConvertFromUtf32(ctr)
        Next
        Console.WriteLine("The string contains {0} characters.", result.Length)
    End Sub
End Module
' The example displays the following output:
'     The string contains 20 characters.

Anda dapat melakukan hal berikut untuk menghindari asumsi bahwa Char objek mewakili satu karakter:

Anda dapat bekerja dengan String objek secara keseluruhan alih-alih bekerja dengan karakter individualnya untuk mewakili dan menganalisis konten linguistik.

Anda dapat menggunakan String.EnumerateRunes seperti yang ditunjukkan dalam contoh berikut:

int CountLetters(string s)
{
    int letterCount = 0;

    foreach (Rune rune in s.EnumerateRunes())
    {
        if (Rune.IsLetter(rune))
        { letterCount++; }
    }

    return letterCount;
}

let countLetters (s: string) =
    let mutable letterCount = 0

    for rune in s.EnumerateRunes() do
        if Rune.IsLetter rune then
            letterCount <- letterCount + 1

    letterCount

Anda dapat menggunakan StringInfo kelas untuk bekerja dengan elemen teks alih-alih objek individual Char . Contoh berikut menggunakan StringInfo objek untuk menghitung jumlah elemen teks dalam string yang terdiri dari angka Aegea nol hingga sembilan. Karena mempertimbangkan pasangan pengganti satu karakter, ia melaporkan dengan benar bahwa string berisi sepuluh karakter.

using System;
using System.Globalization;

public class Example4
{
    public static void Main()
    {
        string result = String.Empty;
        for (int ctr = 0x10107; ctr <= 0x10110; ctr++)  // Range of Aegean numbers.
            result += Char.ConvertFromUtf32(ctr);

        StringInfo si = new StringInfo(result);
        Console.WriteLine("The string contains {0} characters.",
                          si.LengthInTextElements);
    }
}
// The example displays the following output:
//       The string contains 10 characters.

open System
open System.Globalization

let result =
    [ for i in 0x10107..0x10110 do  // Range of Aegean numbers.
        Char.ConvertFromUtf32 i ]
    |> String.concat ""


let si = StringInfo result
printfn $"The string contains {si.LengthInTextElements} characters."

// The example displays the following output:
//       The string contains 10 characters.

Imports System.Globalization

Module Example6
    Public Sub Main()
        Dim result As String = String.Empty
        For ctr As Integer = &H10107 To &H10110     ' Range of Aegean numbers.
            result += Char.ConvertFromUtf32(ctr)
        Next
        Dim si As New StringInfo(result)
        Console.WriteLine("The string contains {0} characters.", si.LengthInTextElements)
    End Sub
End Module
' The example displays the following output:
'       The string contains 10 characters.

Jika string berisi karakter dasar yang memiliki satu atau beberapa karakter gabungan, Anda dapat memanggil String.Normalize metode untuk mengonversi substring ke satu unit kode yang dikodekan UTF-16. Contoh berikut memanggil String.Normalize metode untuk mengonversi karakter dasar U+0061 (LATIN SMALL LETTER A) dan menggabungkan karakter U+0308 (MENGGABUNGKAN DIAERESIS) ke U+00E4 (LATIN SMALL LETTER A WITH DIAERESIS).

using System;

public class Example2
{
    public static void Main()
    {
        string combining = "\u0061\u0308";
        ShowString(combining);

        string normalized = combining.Normalize();
        ShowString(normalized);
    }

    private static void ShowString(string s)
    {
        Console.Write("Length of string: {0} (", s.Length);
        for (int ctr = 0; ctr < s.Length; ctr++)
        {
            Console.Write("U+{0:X4}", Convert.ToUInt16(s[ctr]));
            if (ctr != s.Length - 1) Console.Write(" ");
        }
        Console.WriteLine(")\n");
    }
}
// The example displays the following output:
//       Length of string: 2 (U+0061 U+0308)
//
//       Length of string: 1 (U+00E4)

open System

let showString (s: string) =
    printf $"Length of string: {s.Length} ("
    for i = 0 to s.Length - 1 do
        printf $"U+{Convert.ToUInt16 s[i]:X4}"
        if i <> s.Length - 1 then printf " "
    printfn ")\n"

let combining = "\u0061\u0308"
showString combining

let normalized = combining.Normalize()
showString normalized

// The example displays the following output:
//       Length of string: 2 (U+0061 U+0308)
//
//       Length of string: 1 (U+00E4)

Module Example3
    Public Sub Main()
        Dim combining As String = ChrW(&H61) + ChrW(&H308)
        ShowString(combining)

        Dim normalized As String = combining.Normalize()
        ShowString(normalized)
    End Sub

    Private Sub ShowString(s As String)
        Console.Write("Length of string: {0} (", s.Length)
        For ctr As Integer = 0 To s.Length - 1
            Console.Write("U+{0:X4}", Convert.ToUInt16(s(ctr)))
            If ctr <> s.Length - 1 Then Console.Write(" ")
        Next
        Console.WriteLine(")")
        Console.WriteLine()
    End Sub
End Module
' The example displays the following output:
'       Length of string: 2 (U+0061 U+0308)
'       
'       Length of string: 1 (U+00E4)

Operasi umum

Struktur Char menyediakan metode untuk membandingkan Char objek, mengonversi nilai objek saat ini Char ke objek jenis lain, dan menentukan kategori Unicode objek Char :

Untuk melakukan ini	Gunakan metode ini `System.Char`
Membandingkan Char objek	CompareTo dan Equals
Mengonversi titik kode menjadi string	ConvertFromUtf32 Lihat juga jenisnya Rune .
Char Mengonversi objek atau sepasang Char objek pengganti menjadi titik kode	Untuk satu karakter: Convert.ToInt32(Char) Untuk pasangan pengganti atau karakter dalam string: Char.ConvertToUtf32 Lihat juga jenisnya Rune .
Mendapatkan kategori Unicode karakter	GetUnicodeCategory Lihat juga Rune.GetUnicodeCategory.
Menentukan apakah karakter berada dalam kategori Unicode tertentu seperti digit, huruf, tanda baca, karakter kontrol, dan sebagainya	IsControl, , IsDigit, IsLetter IsHighSurrogate, IsLetterOrDigit, IsLower IsLowSurrogate, IsNumber, , IsPunctuation, IsSeparator, IsSurrogate, , IsSurrogatePair, IsSymbol, IsUpper, danIsWhiteSpace Lihat juga metode yang sesuai pada jenisnya Rune .
Char Mengonversi objek yang mewakili angka menjadi tipe nilai numerik	GetNumericValue Lihat juga Rune.GetNumericValue.
Mengonversi karakter dalam string menjadi Char objek	Parse dan TryParse
Char Mengonversi objek menjadi String objek	ToString
Mengubah huruf besar/kecil Char objek	ToLower, ToLowerInvariant, ToUpper, dan ToUpperInvariant Lihat juga metode yang sesuai pada jenisnya Rune .

Nilai karakter dan interop

Ketika jenis terkelola Char , yang diwakili sebagai unit kode yang dikodekan Unicode UTF-16, diteruskan ke kode yang tidak dikelola, marshaller interop mengonversi karakter yang diatur ke ANSI secara default. Anda dapat menerapkan DllImportAttribute atribut ke deklarasi pemanggilan platform dan StructLayoutAttribute atribut ke deklarasi interop COM untuk mengontrol karakter mana yang mengatur jenis marshal yang Char digunakan.

Bagikan melalui