Udostępnij za pośrednictwem

System.Char, struktura

  • Artykuł

Ten artykuł zawiera dodatkowe uwagi dotyczące dokumentacji referencyjnej dla tego interfejsu API.

Struktura Char reprezentuje punkty kodu Unicode przy użyciu kodowania UTF-16. Wartość Char obiektu to jego 16-bitowa wartość liczbowa (porządkowa).

Jeśli nie znasz formatu Unicode, wartości skalarnych, punktów kodu, par zastępczych, utF-16 i Rune typu, zobacz Wprowadzenie do kodowania znaków na platformie .NET.

W tym artykule omówiono relację między obiektem Char a znakiem i omówiono niektóre typowe zadania wykonywane z Char wystąpieniami. Zalecamy rozważenie typu wprowadzonego Rune na platformie .NET Core 3.0 jako alternatywy Char dla wykonywania niektórych z tych zadań.

Obiekty char, znaki Unicode i ciągi

String Obiekt to sekwencyjny zbiór Char struktur reprezentujący ciąg tekstu. Większość znaków Unicode może być reprezentowana przez pojedynczy Char obiekt, ale znak zakodowany jako znak podstawowy, para zastępcza i/lub łącząca sekwencję znaków jest reprezentowana przez wiele Char obiektów. Z tego powodu Char struktura obiektu String nie musi być równoważna pojedynczemu znakowi Unicode.

Wiele 16-bitowych jednostek kodu służy do reprezentowania pojedynczych znaków Unicode w następujących przypadkach:

  • Glyphs, które mogą składać się z pojedynczego znaku lub znaku podstawowego, po którym następuje co najmniej jeden znak łączący. Na przykład znak ä jest reprezentowany przez Char obiekt, którego jednostka kodu to U+0061, a następnie Char obiekt, którego jednostka kodu to U+0308. (Znak ä może być również zdefiniowany przez pojedynczy Char obiekt, który ma jednostkę kodu U+00E4). Poniższy przykład ilustruje, że znak ä składa się z dwóch Char obiektów.

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

  • Znaki poza podstawową płaszczyzną wielojęzyczną Unicode (BMP). Kod Unicode obsługuje szesnaście płaszczyzn oprócz protokołu BMP, który reprezentuje płaszczyznę 0. Punkt kodu Unicode jest reprezentowany w formacie UTF-32 przez wartość 21-bitową zawierającą płaszczyznę. Na przykład U+1D160 reprezentuje znak Ósmy SYMBOL MUZYCZNY. Ponieważ kodowanie UTF-16 ma tylko 16 bitów, znaki poza BMP są reprezentowane przez pary zastępcze w formacie UTF-16. Poniższy przykład ilustruje, że odpowiednik UTF-32 U+1D160, ZNAK ÓSMEJ NOTATKI SYMBOLU MUZYCZNEgo, jest U+D834 U+DD60. U+D834 jest wysokim zastępcą; wysokie wartości zastępcze wahają się od U+D800 do U+DBFF. U+DD60 jest niskim zastępcą; zakres niskich surogatów od U+DC00 do 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

Znaki i kategorie znaków

Każdy znak Unicode lub prawidłowa para zastępcza należy do kategorii Unicode. Na platformie .NET kategorie Unicode są reprezentowane przez elementy członkowskie UnicodeCategory wyliczenia i zawierają na przykład wartości, takie jak UnicodeCategory.CurrencySymbol, UnicodeCategory.LowercaseLetteri UnicodeCategory.SpaceSeparator.

Aby określić kategorię Unicode znaku, wywołaj metodę GetUnicodeCategory . Na przykład poniższy przykład wywołuje metodę GetUnicodeCategory , aby wyświetlić kategorię Unicode każdego znaku w ciągu. Przykład działa poprawnie tylko wtedy, gdy w wystąpieniu String nie ma par zastępczych.

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

Wewnętrznie w przypadku znaków spoza zakresu ASCII (od U+0000 do U+00FF) GetUnicodeCategory metoda zależy od kategorii Unicode zgłoszonych przez klasę CharUnicodeInfo . Począwszy od programu .NET Framework 4.6.2, znaki Unicode są klasyfikowane na podstawie standardu Unicode w wersji 8.0.0. W wersjach programu .NET Framework z programu .NET Framework 4 do .NET Framework 4.6.1 są one klasyfikowane na podstawie standardu Unicode w wersji 6.3.0.

Znaki i elementy tekstowe

Ponieważ pojedynczy znak może być reprezentowany przez wiele Char obiektów, nie zawsze ma znaczenia, aby pracować z poszczególnymi Char obiektami. Na przykład poniższy przykład konwertuje punkty kodu Unicode reprezentujące liczby Morza Egejskiego od 9 do 9 do zakodowanych jednostek kodu UTF-16. Ponieważ błędnie oznacza Char obiekty znakami, niedokładnie zgłasza, że wynikowy ciąg ma 20 znaków.

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.

Aby uniknąć założenia, że Char obiekt reprezentuje pojedynczy znak, można wykonać następujące czynności:

  • Możesz pracować z obiektem String w całości zamiast pracować z poszczególnymi znakami, aby reprezentować i analizować zawartość językową.

  • Możesz użyć metody String.EnumerateRunes , jak pokazano w poniższym przykładzie:

    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

  • Klasę StringInfo można używać do pracy z elementami tekstowymi zamiast pojedynczych Char obiektów. W poniższym przykładzie StringInfo użyto obiektu do zliczenia liczby elementów tekstowych w ciągu składającym się z liczb Morza Egejskiego od zera do dziewięciu. Ponieważ uważa ona parę zastępczą za pojedynczy znak, prawidłowo zgłasza, że ciąg zawiera dziesięć znaków.

    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.

  • Jeśli ciąg zawiera znak podstawowy, który ma co najmniej jeden znak łączący, możesz wywołać String.Normalize metodę w celu przekonwertowania podciągów na pojedynczą jednostkę kodu zakodowanego w formacie UTF-16. W poniższym przykładzie metoda wywołuje metodę String.Normalize , aby przekonwertować znak podstawowy U+0061 (MAŁA LITERA A) i łącząc znak U+0308 (ŁĄCZENIE DIAERESIS) na U+00E4 (MAŁA LITERA ŁACIŃSKA A Z DIAEREZĄ).

    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)

Typowe operacje

Struktura Char udostępnia metody porównywania Char obiektów, konwertowania wartości bieżącego Char obiektu na obiekt innego typu i określania kategorii Char Unicode obiektu:

Czynność Użyj tych System.Char metod
Porównywanie Char obiektów CompareTo i Equals
Konwertowanie punktu kodu na ciąg ConvertFromUtf32

Zobacz również Rune typ.
Char Konwertowanie obiektu lub zastępczej Char pary obiektów na punkt kodu Dla pojedynczego znaku: Convert.ToInt32(Char)

Dla pary zastępczej lub znaku w ciągu: Char.ConvertToUtf32

Zobacz również Rune typ.
Pobieranie kategorii Unicode znaku GetUnicodeCategory

Zobacz też Rune.GetUnicodeCategory.
Określanie, czy znak znajduje się w określonej kategorii Unicode, takiej jak cyfra, litera, znak interpunkcyjny, znak kontrolny itd. IsControl, IsDigit, , IsHighSurrogate, IsLetterOrDigitIsUpperIsSymbolIsSurrogatePairIsSurrogateIsPunctuationIsLowSurrogateIsSeparatorIsLetterIsLowerIsNumberiIsWhiteSpace

Zobacz również odpowiednie metody dla Rune typu.
Char Konwertowanie obiektu reprezentującego liczbę na typ wartości liczbowej GetNumericValue

Zobacz też Rune.GetNumericValue.
Konwertowanie znaku w ciągu na Char obiekt Parse i TryParse
Konwertowanie Char obiektu na String obiekt ToString
Zmienianie wielkości liter Char obiektu ToLower, ToLowerInvariant, ToUpperi ToUpperInvariant

Zobacz również odpowiednie metody dla Rune typu.

Wartości znaków i międzyoperajności

Gdy typ zarządzany Char , który jest reprezentowany jako jednostka kodu zakodowanego w formacie Unicode UTF-16, jest przekazywany do niezarządzanego kodu, międzyoperator konwertuje znak ustawiony na ANSI domyślnie. Atrybut można zastosować DllImportAttribute do deklaracji wywołania platformy i StructLayoutAttribute atrybutu do deklaracji międzyoperacyjnej COM, aby kontrolować, który zestaw znaków jest używany przez marshaled Char type.