System.Char struktur

Anmärkning

Den här artikeln innehåller ytterligare kommentarer till referensdokumentationen för det här API:et.

Strukturen Char representerar Unicode-kodpunkter med hjälp av UTF-16-kodning. Värdet för ett Char objekt är dess 16-bitars numeriska värde (ordningstal).

Om du inte är bekant med Unicode, skalärvärden, kodpunkter, surrogatpar, UTF-16 och Rune typen läser du Introduktion till teckenkodning i .NET.

Den här artikeln undersöker relationen mellan ett Char objekt och ett tecken och diskuterar några vanliga uppgifter som utförs med Char instanser. Vi rekommenderar att du överväger den Rune-typ som introducerades i .NET Core 3.0 som ett alternativ till Char för att utföra vissa av dessa uppgifter.

Teckenobjekt, Unicode-tecken och strängar

Ett String objekt är en sekventiell samling Char strukturer som representerar en textsträng. De flesta Unicode-tecken kan representeras av ett enskilt Char objekt, men ett tecken som kodas som bastecken, surrogatpar och/eller kombination av teckensekvens representeras av flera Char objekt. Därför är en Char struktur i ett String objekt inte nödvändigtvis likvärdig med ett enda Unicode-tecken.

Flera 16-bitars kodenheter används för att representera enskilda Unicode-tecken i följande fall:

  • Tecken, som kan bestå av ett enskilt tecken eller ett bastecken följt av ett eller flera kombinationstecken. Till exempel representeras ä av ett Char objekt vars kodenhet är U+0061 följt av ett Char objekt vars kodenhet är U+0308. (Tecknet ä kan också definieras av ett enskilt Char objekt som har en kodenhet på U+00E4.) I följande exempel visas att tecknet ä består av två 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:
'       ä

  • Tecken utanför Unicode Basic Multilingual Plane (BMP). Unicode stöder sexton plan utöver BMP, som representerar plan 0. En Unicode-kodpunkt representeras i UTF-32 av ett 21-bitars värde som innehåller planet. Till exempel representerar U+1D160 tecknet MUSIKALISK SYMBOL ÅTTONDE NOT. Eftersom UTF-16-kodning bara har 16 bitar representeras tecken utanför BMP av surrogatpar i UTF-16. I följande exempel visas att UTF-32-motsvarigheten till U+1D160, tecknet MUSICAL SYMBOL EIGHTH NOTE, är U+D834 U+DD60. U+D834 är den högre surrogatpunkten; högre surrogater sträcker sig från U+D800 till U+DBFF. U+DD60 är ett lågt surrogat; låga surrogat sträcker sig från U+DC00 till 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

Tecken- och teckenkategorier

Varje Unicode-tecken eller ett giltigt surrogatpar tillhör en Unicode-kategori. I .NET representeras Unicode-kategorier av medlemmar i UnicodeCategory uppräkningen och inkluderar värden som UnicodeCategory.CurrencySymbol, UnicodeCategory.LowercaseLetteroch UnicodeCategory.SpaceSeparator, till exempel.

Om du vill fastställa Unicode-kategorin för ett tecken anropar du GetUnicodeCategory metoden. I följande exempel anropas GetUnicodeCategory till exempel för att visa Unicode-kategorin för varje tecken i en sträng. Exemplet fungerar bara korrekt om det inte finns några surrogatpar i instansen String .

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

För intern användning, när det gäller tecken utanför ASCII-intervallet för Unicode (U+0000 till U+00FF), beror metoden GetUnicodeCategory på de Unicode-kategorier som rapporteras av klassen CharUnicodeInfo. Från och med .NET Framework 4.6.2 klassificeras Unicode-tecken baserat på Unicode Standard, version 8.0.0. I versioner av .NET Framework från .NET Framework 4 till .NET Framework 4.6.1 klassificeras de baserat på Unicode Standard, version 6.3.0.

Tecken och textelement

Eftersom ett enskilt tecken kan representeras av flera Char objekt är det inte alltid meningsfullt att arbeta med enskilda Char objekt. I följande exempel konverteras till exempel Unicode-kodpunkterna som representerar egeiska talen noll till och med 9 till UTF-16-kodade kodenheter. Eftersom det felaktigt likställer Char objekt med tecken, rapporterar den felaktigt att den resulterande strängen har 20 tecken.

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.

Du kan göra följande för att undvika antagandet att ett Char objekt representerar ett enda tecken:

  • Du kan arbeta med ett String objekt i sin helhet i stället för att arbeta med dess enskilda tecken för att representera och analysera språkligt innehåll.

  • Du kan använda String.EnumerateRunes som du ser i följande exempel:

    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

  • Du kan använda StringInfo klassen för att arbeta med textelement i stället för enskilda Char objekt. I följande exempel används objektet StringInfo för att räkna antalet textelement i en sträng som består av egeiska tal noll till nio. Eftersom det betraktar ett surrogatpar som ett enda tecken, rapporterar det korrekt att strängen innehåller tio tecken.

    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.

  • Om en sträng innehåller ett bastecken som innehåller ett eller flera kombinationstecken kan du anropa String.Normalize metoden för att konvertera delsträngen till en enda UTF-16-kodad kodenhet. I följande exempel anropas String.Normalize metoden för att konvertera bastecknet U+0061 (LATIN SMALL LETTER A) och kombinera tecknet U+0308 (KOMBINERA DIAERESIS) till 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)

Vanliga åtgärder

Strukturen Char innehåller metoder för att jämföra Char objekt, konvertera värdet för det aktuella Char objektet till ett objekt av en annan typ och fastställa Unicode-kategorin för ett Char objekt:

Så här gör du Använd dessa System.Char metoder
Jämför Char objekt CompareTo och Equals
Konvertera en kodpunkt till en sträng ConvertFromUtf32

Se även typ Rune .
Konvertera ett Char objekt eller ett surrogatpar med Char objekt till en kodpunkt För ett enskilt tecken: Convert.ToInt32(Char)

För ett surrogatpar eller ett tecken i en sträng: Char.ConvertToUtf32

Se även typ Rune .
Hämta Unicode-kategorin för ett tecken GetUnicodeCategory

Se även Rune.GetUnicodeCategory.
Avgör om ett tecken finns i en viss Unicode-kategori, till exempel siffra, bokstav, skiljetecken, kontrolltecken och så vidare IsControl, IsDigit, IsHighSurrogate, IsLetter, IsLetterOrDigit, IsLower, IsLowSurrogate, IsNumber, IsPunctuation, IsSeparator, , IsSurrogate, IsSurrogatePair, IsSymbol, IsUpperoch IsWhiteSpace

Se även motsvarande metoder för Rune typen.
Konvertera ett Char objekt som representerar ett tal till en numerisk värdetyp GetNumericValue

Se även Rune.GetNumericValue.
Konvertera ett tecken i en sträng till ett Char objekt Parse och TryParse
Konvertera ett Char objekt till ett String objekt ToString
Ändra ett objekts Char skiftläge ToLower, ToLowerInvariant, ToUpperoch ToUpperInvariant

Se även motsvarande metoder för Rune typen.

Teckenvärden och interoperabilitet

När en hanterad Char typ, som representeras som en Unicode UTF-16-kodad kodenhet, skickas till o-hanterad kod konverterar interop marshaller teckenuppsättningen till ANSI som standard. Du kan använda DllImportAttribute attributet för plattformsanropsdeklarationer och StructLayoutAttribute attributet för en COM-interopdeklaration för att styra vilka tecken som en konverterad Char typ använder.

  • Last updated on