Sdílet prostřednictvím


System.Char – struktura

Tento článek obsahuje doplňující poznámky k referenční dokumentaci pro toto rozhraní API.

Struktura Char představuje body kódu Unicode pomocí kódování UTF-16. Hodnota objektu Char je její 16bitová číselná (pořadová) hodnota.

Pokud neznáte Unicode, skalární hodnoty, body kódu, náhradní dvojice, UTF-16 a Rune typ, přečtěte si téma Úvod do kódování znaků v .NET.

Tento článek zkoumá vztah mezi objektem Char a znakem a popisuje některé běžné úlohy prováděné s Char instancemi. Jako alternativu Rune k Char provádění některých z těchto úloh doporučujeme zvážit typ zavedený v .NET Core 3.0.

Znakové objekty, znaky Unicode a řetězce

Objekt String je sekvenční kolekce Char struktur, které představují řetězec textu. Většina znaků Unicode může být reprezentována jedním Char objektem, ale znak kódovaný jako základní znak, náhradní dvojice a/nebo kombinování sekvence znaků je reprezentován více Char objekty. Z tohoto důvodu Char není struktura v objektu String nutně ekvivalentní jednomu znaku Unicode.

Několik 16bitových jednotek kódu se používá k reprezentaci jednoduchých znaků Unicode v následujících případech:

  • Glyfy, které se mohou skládat z jednoho znaku nebo základního znaku následovaného jedním nebo více kombinačními znaky. Například znak ä je reprezentován objektem Char , jehož jednotka kódu je U+0061 následovaná objektem Char , jehož jednotka kódu je U+0308. (Znak ä lze také definovat jedním Char objektem, který má jednotku kódu U+00E4.) Následující příklad ukazuje, že znak ä se skládá ze dvou Char objektů.

    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:
    //       ä
    
    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:
    //       ä
    
    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:
    '       ä
    
  • Znaky mimo základní vícejazyčnou rovinu unicode (BMP). Unicode podporuje kromě BMP šestnáct rovin, což představuje rovinu 0. Bod kódu Unicode je reprezentován v kódování UTF-32 21bitovou hodnotou, která zahrnuje rovinu. Například U+1D160 představuje znak OSMÉ POZNÁMKY SYMBOLU MUSICAL. Vzhledem k tomu, že kódování UTF-16 má pouze 16 bitů, znaky mimo BMP jsou reprezentovány náhradními páry v UTF-16. Následující příklad ukazuje, že UTF-32 ekvivalent U+1D160, ZNAK OSMH NOTE, JE U+D834 U+DD60. U+D834 je vysoká náhrada; vysoké náhrady jsou v rozsahu od U+D800 až po U+DBFF. U+DD60 je nízká náhrada; nízký rozsah náhradních dotazů je od U+DC00 až po 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
    

Znaky a kategorie znaků

Každý znak Unicode nebo platný náhradní pár patří do kategorie Unicode. V .NET jsou kategorie Unicode reprezentovány členy výčtu UnicodeCategory a zahrnují hodnoty, jako UnicodeCategory.CurrencySymbolje , UnicodeCategory.LowercaseLettera UnicodeCategory.SpaceSeparator, například.

Chcete-li určit kategorii Unicode znaku, zavolejte metodu GetUnicodeCategory . Například následující příklad volá GetUnicodeCategory zobrazení kategorie Unicode každého znaku v řetězci. Příklad funguje správně pouze v případě, že v String instanci nejsou žádné náhradní páry.

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

Interně pro znaky mimo rozsah ASCII (U+0000 až U+00FF) GetUnicodeCategory metoda závisí na kategoriích Unicode hlášených CharUnicodeInfo třídou. Počínaje rozhraním .NET Framework 4.6.2 jsou znaky Unicode klasifikovány na základě standardu Unicode verze 8.0.0. Ve verzích rozhraní .NET Framework z rozhraní .NET Framework 4 až .NET Framework 4.6.1 jsou klasifikovány na základě standardu Unicode verze 6.3.0.

Znaky a textové prvky

Vzhledem k tomu, že jeden znak může být reprezentován více Char objekty, není vždy smysluplné pracovat s jednotlivými Char objekty. Následující příklad například převede body kódu Unicode, které představují nula egejských čísel až 9 do jednotek kódu kódování UTF-16. Protože chybně odpovídá Char objektům se znaky, nepřesně hlásí, že výsledný řetězec má 20 znaků.

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.

Pokud se chcete vyhnout předpokladu, že objekt představuje jeden znak, Char můžete udělat toto:

  • Místo práce s jeho jednotlivými znaky můžete pracovat s objektem String v plném rozsahu, abyste mohli reprezentovat a analyzovat lingvistický obsah.

  • Můžete použít String.EnumerateRunes , jak je znázorněno v následujícím příkladu:

    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
    
  • Třídu můžete použít StringInfo k práci s textovými prvky místo s jednotlivými Char objekty. Následující příklad používá StringInfo objekt k počítání počtu textových prvků v řetězci, který se skládá z egejských čísel nula až devět. Vzhledem k tomu, že považuje náhradní dvojici jeden znak, správně hlásí, že řetězec obsahuje deset znaků.

    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.
    
  • Pokud řetězec obsahuje základní znak, který má jeden nebo více kombinujících znaků, můžete volat metodu String.Normalize , která převede podřetězce na jednu jednotku kódu kódování UTF-16. Následující příklad volá metodu String.Normalize , která převede základní znak U+0061 (MALÉ PÍSMENO LATINKY A) a zkombinuje znak U+0308 (COMBINING DIAERESIS) na 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)
    

Běžné operace

Struktura Char poskytuje metody pro porovnání Char objektů, převést hodnotu aktuálního Char objektu na objekt jiného typu a určit kategorii Unicode objektu Char :

Akce Použití těchto System.Char metod
Porovnání Char objektů CompareTo a Equals
Převedení bodu kódu na řetězec ConvertFromUtf32

Viz také typ Rune .
Převedení objektu Char nebo náhradní dvojice Char objektů na bod kódu Pro jeden znak: Convert.ToInt32(Char)

Pro náhradní dvojici nebo znak v řetězci: Char.ConvertToUtf32

Viz také typ Rune .
Získání kategorie Unicode znaku GetUnicodeCategory

Viz také Rune.GetUnicodeCategory.
Určete, jestli je znak v konkrétní kategorii Unicode, například číslice, písmeno, interpunkce, řídicí znak atd. IsControl, IsDigit, , , IsLetterOrDigitIsLowerIsSurrogatePairIsSymbolIsLetterIsNumberIsUpperIsLowSurrogateIsPunctuationIsSeparatorIsSurrogateIsHighSurrogateIsWhiteSpace

Viz také odpovídající metody typu Rune .
Převedení objektu Char představujícího číslo na číselný typ hodnoty GetNumericValue

Viz také Rune.GetNumericValue.
Převedení znaku v řetězci na Char objekt Parse a TryParse
Char Převedení objektu String na objekt ToString
Změna velikosti písmen objektu Char ToLower, ToLowerInvariant, ToUppera ToUpperInvariant

Viz také odpovídající metody typu Rune .

Hodnoty znaků a interoperabilita

Pokud se spravovaný Char typ, který je reprezentován jako jednotka kódu kódování Unicode UTF-16, předá nespravovanému kódu, nástroj interop marshaller ve výchozím nastavení převede znakovou sadu na ANSI. Atribut můžete použít DllImportAttribute pro vyvolání deklarací platformy a StructLayoutAttribute atribut na deklaraci zprostředkovatele komunikace modelu COM, která určuje, která znaková sada používá zařazovaný Char typ.