System.Char struktúra

Megjegyzés:

Ez a cikk kiegészítő megjegyzéseket tartalmaz az API referenciadokumentációjához.

A Char struktúra Unicode-kódpontokat jelöl UTF-16 kódolással. Egy objektum értéke Char a 16 bites numerikus (ordinális) értéke.

Ha nem ismeri a Unicode-ot, a skaláris értékeket, a kódpontokat, a helyettesítő párokat, az UTF-16-ot és a típust, olvassa el a Rune.NET-ben használt karakterkódolás bemutatása című témakört.

Ez a cikk egy objektum és egy Char karakter közötti kapcsolatot vizsgál, és ismertet néhány gyakori feladatot, amelyeket Char példányokkal végeznek. Azt javasoljuk, hogy fontolja meg a .NET Core 3.0-ban bevezetett Rune típus használatát, amely alternatívaként szolgálhat Char bizonyos feladatok elvégzéséhez.

Karakterobjektumok, Unicode-karakterek és sztringek

Az String objektumok olyan struktúrák szekvenciális gyűjteményei Char , amelyek egy szöveges sztringet jelölnek. A Unicode-karakterek többségét egyetlen Char objektum jelölheti, de az alapkarakterek, a helyettesítő párok és/vagy a karaktersorozatok egyesítését több Char objektum jelöli. Ezért egy CharString objektum struktúrája nem feltétlenül egyenértékű egyetlen Unicode-karakterrel.

A rendszer több 16 bites kódegységet használ egyetlen Unicode-karakter megjelenítésére a következő esetekben:

  • Karakterjelek, amelyek egyetlen karakterből vagy alap karakterből állhatnak, amelyet egy vagy több egyesítő karakter követ. Az ä karaktert például egy Char olyan objektum jelöli, amelynek kódegysége U+0061, majd egy Char olyan objektum, amelynek kódegysége U+0308. (Az ä karaktert egyetlen Char objektum is definiálhatja, amely az U+00E4 kódegységével rendelkezik.) Az alábbi példa azt szemlélteti, hogy az ä karakter két Char objektumból áll.

    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:
'       ä

  • A Unicode basic többnyelvű síkon (BMP) kívül eső karakterek. A Unicode a BMP mellett tizenhat síkot is támogat, amely a 0 síkot jelöli. A Unicode-kódpontokat az UTF-32-ben egy 21 bites érték jelöli, amely tartalmazza a síkot. Az U+1D160 például a ZENEI SZIMBÓLUM NYOLCADIK JEGYZET karakterét jelöli. Mivel az UTF-16 kódolás csak 16 bittel rendelkezik, a BMP-n kívüli karaktereket helyettesítő párok képviselik az UTF-16-ban. Az alábbi példa azt szemlélteti, hogy az U+1D160 UTF-32 megfelelője, a MUSICAL SYMBOL NYOLCADIK JEGYZET karaktere U+D834 U+DD60. U+D834 a felső helyettesítő; a felső helyettesítők tartománya U+D800 és U+DBFF között van. U+DD60 az alacsony helyettesítő; az alacsony helyettesítők tartománya U+DC00 és U+DFFF között van.

    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

Karakterek és karakterkategóriák

Minden Unicode-karakter vagy érvényes helyettesítő pár Unicode-kategóriához tartozik. A .NET-ben a Unicode-kategóriákat az UnicodeCategory enumerálás tagjai jelölik, és olyan értékeket tartalmaznak, mint UnicodeCategory.CurrencySymbolpéldául a , UnicodeCategory.LowercaseLetterés UnicodeCategory.SpaceSeparatorpéldául.

Egy karakter Unicode-kategóriájának meghatározásához hívja meg a metódust GetUnicodeCategory . Az alábbi példa például meghívja az GetUnicodeCategory egyes karakterek Unicode-kategóriájának megjelenítésére egy sztringben. A példa csak akkor működik megfelelően, ha a példányban String nincsenek szurrogát párok.

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($"'{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

Az ASCII tartományon túli karakterek esetén (U+0080–U+00FF) a GetUnicodeCategory metódus a CharUnicodeInfo osztály által meghatározott Unicode-kategóriáktól függ. A .NET-keretrendszer 4.6.2-es verziójától kezdve a Unicode-karakterek a Unicode Standard 8.0.0-s verziója alapján vannak besorolva. A .NET-keretrendszer .NET-keretrendszer 4-es és .NET-keretrendszer 4.6.1-es verzióiban a rendszer a Unicode Standard 6.3.0-s verziója alapján osztályozza őket.

Karakterek és szövegelemek

Mivel egyetlen karakter több Char objektummal is ábrázolható, nem mindig hasznos az egyes Char objektumok használata. Az alábbi példa például UTF-16 kódolású kódegységekké alakítja a nulla és 9 között az égei számokat képviselő Unicode-kódpontokat. Mivel tévesen egyezteti az Char objektumokat a karakterekkel, pontatlanul jelenti, hogy az eredményül kapott sztring 20 karakterből áll.

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 {result.Length} characters.");
    }
}
// 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.

Az alábbiakat követve elkerülheti azt a feltételezést, hogy egy Char objektum egyetlen karaktert jelöl:

  • Az String objektumot teljes egészében használhatja ahelyett, hogy az egyes karakterekkel dolgozna a nyelvi tartalom ábrázolása és elemzése céljából.

  • A következő példában látható módon használható String.EnumerateRunes :

    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

  • Az osztály használatával az StringInfo egyes Char objektumok helyett szövegelemekkel dolgozhat. Az alábbi példa az objektumot használja a StringInfo szöveges elemek számának megszámlálására egy sztringben, amely az Égei-számok nullától kilencig való számából áll. Mivel egy helyettesítő párt egyetlen karakternek tekint, helyesen jelenti, hogy a karakterlánc tíz karaktert tartalmaz.

    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 {si.LengthInTextElements} characters.");
    }
}
// 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.

  • Ha egy sztring egy vagy több egyesítési karaktert tartalmazó alapkaraktert tartalmaz, meghívhatja a String.Normalize metódust, hogy az alsztringet egyetlen UTF-16 kódolt kódegységre konvertálja. Az alábbi példa az String.Normalize metódust hívja meg, hogy az alapkarakter U+0061 (LATIN KISBETŰ A) és a kombináló karakter U+0308 (KETTŐSPONT) együttesen U+00E4 (LATIN KISBETŰ A KETTŐSPONTTAL) karakterré alakuljon át.

    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)

Gyakori műveletek

A Char struktúra metódusokat biztosít az objektumok összehasonlításához Char , az aktuális Char objektum értékének egy másik típusú objektummá alakításához, valamint egy objektum Unicode-kategóriájának meghatározásához Char :

Ehhez Használja ezeket a System.Char módszereket
Objektumok összehasonlítása Char CompareTo és Equals
Kódpont átalakítása sztringgé ConvertFromUtf32

Lásd még a típust Rune .
Char Objektum vagy helyettesítő objektumpár Char átalakítása kódponttá Egyetlen karakter esetén: Convert.ToInt32(Char)

Helyettesítő pár vagy sztringben szereplő karakter esetén: Char.ConvertToUtf32

Lásd még a típust Rune .
Karakter Unicode-kategóriájának lekérése GetUnicodeCategory

Lásd még: Rune.GetUnicodeCategory.
Annak meghatározása, hogy egy karakter egy adott Unicode-kategóriába tartozik-e, például számjegy, betű, írásjel, vezérlő karakter stb. IsControl, IsDigit, IsHighSurrogate, IsLetter, IsLetterOrDigit, IsLower, IsLowSurrogate, IsNumber, IsPunctuation, IsSeparator, IsSurrogate, IsSurrogatePair, IsSymbol, IsUpper és IsWhiteSpace

Lásd még a Rune típus megfelelő metódusait.
Char Számokat ábrázoló objektum átalakítása numerikus értéktípussá GetNumericValue

Lásd még: Rune.GetNumericValue.
Sztring karakterének átalakítása objektummá Char Parse és TryParse
Char Objektum átalakítása objektummá String ToString
Egy Char objektum betűméretét módosítsa ToLower, ToLowerInvariant, ToUpperés ToUpperInvariant

Lásd még a Rune típus megfelelő metódusait.

Karakterértékek és interoperabilitás

Ha egy unicode UTF-16 kódolt kódegységként ábrázolt felügyelt Char típust nem felügyelt kódnak ad át, az interop-marshaller alapértelmezés szerint ANSI-vé alakítja a karakterkészletet. Az attribútumot a DllImportAttribute platformhívási deklarációkra, az StructLayoutAttribute attribútumot pedig egy COM-interop deklarációra alkalmazhatja annak szabályozására, hogy melyik karaktert használja a rögzített Char típus.

  • Last updated on