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.