Char Struktura

Definicja

Reprezentuje znak jako jednostkę kodu UTF-16.

public value class char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
public value class char : IComparable, IComparable<char>, IConvertible, IEquatable<char>, ISpanFormattable
public value class char : IComparable, IConvertible
public value class char : IComparable, IComparable<char>, IEquatable<char>
public struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
public struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>, ISpanFormattable
[System.Serializable]
public struct Char : IComparable, IConvertible
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
public struct Char : IComparable, IComparable<char>, IEquatable<char>
type char = struct
    interface IConvertible
type char = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable
[<System.Serializable>]
type char = struct
    interface IConvertible
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type char = struct
    interface IConvertible
type char = struct
Public Structure Char
Implements IComparable, IComparable(Of Char), IConvertible, IEquatable(Of Char)
Public Structure Char
Implements IComparable, IComparable(Of Char), IConvertible, IEquatable(Of Char), ISpanFormattable
Public Structure Char
Implements IComparable, IConvertible
Public Structure Char
Implements IComparable, IComparable(Of Char), IEquatable(Of Char)
Dziedziczenie
Atrybuty
Implementuje

Przykłady

Poniższy przykład kodu przedstawia niektóre metody w Char .

using namespace System;
int main()
{
   char chA = 'A';
   char ch1 = '1';
   String^ str =  "test string";
   Console::WriteLine( chA.CompareTo( 'B' ) ); // Output: "-1" (meaning 'A' is 1 less than 'B')
   Console::WriteLine( chA.Equals( 'A' ) ); // Output: "True"
   Console::WriteLine( Char::GetNumericValue( ch1 ) ); // Output: "1"
   Console::WriteLine( Char::IsControl( '\t' ) ); // Output: "True"
   Console::WriteLine( Char::IsDigit( ch1 ) ); // Output: "True"
   Console::WriteLine( Char::IsLetter( ',' ) ); // Output: "False"
   Console::WriteLine( Char::IsLower( 'u' ) ); // Output: "True"
   Console::WriteLine( Char::IsNumber( ch1 ) ); // Output: "True"
   Console::WriteLine( Char::IsPunctuation( '.' ) ); // Output: "True"
   Console::WriteLine( Char::IsSeparator( str, 4 ) ); // Output: "True"
   Console::WriteLine( Char::IsSymbol( '+' ) ); // Output: "True"
   Console::WriteLine( Char::IsWhiteSpace( str, 4 ) ); // Output: "True"
   Console::WriteLine( Char::Parse(  "S" ) ); // Output: "S"
   Console::WriteLine( Char::ToLower( 'M' ) ); // Output: "m"
   Console::WriteLine( 'x' ); // Output: "x"
}
using System;

public class CharStructureSample
{
    public static void Main()
    {
        char chA = 'A';
        char ch1 = '1';
        string str = "test string";

        Console.WriteLine(chA.CompareTo('B'));          //-----------  Output: "-1" (meaning 'A' is 1 less than 'B')
        Console.WriteLine(chA.Equals('A'));             //-----------  Output: "True"
        Console.WriteLine(Char.GetNumericValue(ch1));   //-----------  Output: "1"
        Console.WriteLine(Char.IsControl('\t'));        //-----------  Output: "True"
        Console.WriteLine(Char.IsDigit(ch1));           //-----------  Output: "True"
        Console.WriteLine(Char.IsLetter(','));          //-----------  Output: "False"
        Console.WriteLine(Char.IsLower('u'));           //-----------  Output: "True"
        Console.WriteLine(Char.IsNumber(ch1));          //-----------  Output: "True"
        Console.WriteLine(Char.IsPunctuation('.'));     //-----------  Output: "True"
        Console.WriteLine(Char.IsSeparator(str, 4));    //-----------  Output: "True"
        Console.WriteLine(Char.IsSymbol('+'));          //-----------  Output: "True"
        Console.WriteLine(Char.IsWhiteSpace(str, 4));   //-----------  Output: "True"
        Console.WriteLine(Char.Parse("S"));             //-----------  Output: "S"
        Console.WriteLine(Char.ToLower('M'));           //-----------  Output: "m"
        Console.WriteLine('x'.ToString());              //-----------  Output: "x"
    }
}
open System

let chA = 'A'
let ch1 = '1'
let str = "test string"

printfn $"{chA.CompareTo 'B'}"          //-----------  Output: "-1" (meaning 'A' is 1 less than 'B')
printfn $"{chA.Equals 'A'}"             //-----------  Output: "True"
printfn $"{Char.GetNumericValue ch1}"   //-----------  Output: "1"
printfn $"{Char.IsControl '\t'}"        //-----------  Output: "True"
printfn $"{Char.IsDigit ch1}"           //-----------  Output: "True"
printfn $"{Char.IsLetter ','}"          //-----------  Output: "False"
printfn $"{Char.IsLower 'u'}"           //-----------  Output: "True"
printfn $"{Char.IsNumber ch1}"          //-----------  Output: "True"
printfn $"{Char.IsPunctuation '.'}"     //-----------  Output: "True"
printfn $"{Char.IsSeparator(str, 4)}"   //-----------  Output: "True"
printfn $"{Char.IsSymbol '+'}"          //-----------  Output: "True"
printfn $"{Char.IsWhiteSpace(str, 4)}"  //-----------  Output: "True"
printfn $"""{Char.Parse "S"}"""         //-----------  Output: "S"
printfn $"{Char.ToLower 'M'}"           //-----------  Output: "m"
printfn $"{'x'}"                        //-----------  Output: "x"
Module CharStructure

    Public Sub Main()

        Dim chA As Char
        chA = "A"c
        Dim ch1 As Char
        ch1 = "1"c
        Dim str As String
        str = "test string"

        Console.WriteLine(chA.CompareTo("B"c))          ' Output: "-1" (meaning 'A' is 1 less than 'B')
        Console.WriteLine(chA.Equals("A"c))             ' Output: "True"
        Console.WriteLine(Char.GetNumericValue(ch1))    ' Output: "1"
        Console.WriteLine(Char.IsControl(Chr(9)))       ' Output: "True"
        Console.WriteLine(Char.IsDigit(ch1))            ' Output: "True"
        Console.WriteLine(Char.IsLetter(","c))          ' Output: "False"
        Console.WriteLine(Char.IsLower("u"c))           ' Output: "True"
        Console.WriteLine(Char.IsNumber(ch1))           ' Output: "True"
        Console.WriteLine(Char.IsPunctuation("."c))     ' Output: "True"
        Console.WriteLine(Char.IsSeparator(str, 4))     ' Output: "True"
        Console.WriteLine(Char.IsSymbol("+"c))          ' Output: "True"
        Console.WriteLine(Char.IsWhiteSpace(str, 4))    ' Output: "True"
        Console.WriteLine(Char.Parse("S"))              ' Output: "S"
        Console.WriteLine(Char.ToLower("M"c))           ' Output: "m"
        Console.WriteLine("x"c.ToString())              ' Output: "x"

    End Sub

End Module

Uwagi

.NET używa struktury Char do reprezentowania punktów kodu Unicode przy użyciu kodowania UTF-16. Wartość obiektu jest Char jego 16-bitową wartością liczbową (porządkową).

Jeśli nie znasz formatu Unicode, wartości skalarnych, punktów kodu, par zastępczych, formatu UTF-16 i typu, zobacz Introduction to character encoding in .NET (Wprowadzenie do kodowania znaków na Rune .NET).

W poniższych sekcjach omówiono relację między obiektem i znakiem oraz omówiono niektóre Char typowe zadania wykonywane za pomocą Char wystąpień. Zalecamy rozważenie typu wprowadzonego w Rune programie .NET Core 3.0 jako alternatywy dla wykonywania Char niektórych z tych zadań.

Obiekty char, znaki Unicode i ciągi

Obiekt String to sekwencyjna kolekcja Char struktur, która reprezentuje ciąg tekstowy. Większość znaków Unicode może być reprezentowana przez pojedynczy obiekt, ale znak, który jest kodowany jako znak podstawowy, para surogatów i/lub łączenie sekwencji znaków, jest reprezentowany przez Char wiele Char obiektów. Z tego powodu struktura Char w obiekcie String nie musi być równoważna pojedynczeowi znakowi Unicode.

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

  • Glify, które mogą składać się z jednego znaku lub znaku podstawowego, po którym następuje co najmniej jeden znak łączący. Na przykład znak za pomocą obiektu, którego jednostka kodu to U+0061, po którym następuje obiekt, którego jednostka kodu to Char Char U+0308. (Znak za pomocą pojedynczego obiektu, który ma jednostkę kodu Char U+00E4). Poniższy przykład ilustruje, że znak owanego składa się z dwóch Char obiektów.

    using System;
    using System.IO;
    
    public class Example
    {
       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 Example
       Public Sub Main()
          Dim sw As New StreamWriter("chars1.txt")
          Dim chars() As Char = { ChrW(&h0061), ChrW(&h0308) }
          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). Unicode obsługuje szesnastu płaszczyzn oprócz BMP, który reprezentuje płaszczyznę 0. Punkt kodu Unicode jest reprezentowany w formacie UTF-32 przez wartość 21-bitową, która zawiera płaszczyznę. Na przykład znak U+1D160 reprezentuje znak SYMBOLU ÓSMEJ UWAGI. Ponieważ kodowanie UTF-16 ma tylko 16 bitów, znaki poza BMP są reprezentowane przez pary zastępcze w FORF-16. W poniższym przykładzie pokazano, że odpowiednik UTF-32 znaku U+1D160, symbolu SYMBOLU Ósmej notatki, to U+D834 U+DD60. U + D834 jest wysoki surogat; zakres wysokich surogatów od U+D800 do U+DBFF. U +DD60 to niski surogat; Zakres niskich surogatów od U + DC00 do U + DFFF.

    using System;
    using System.IO;
    
    public class Example
    {
       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 Example
       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 surogatów należy do kategorii Unicode. Na platformie .NET kategorie Unicode są reprezentowane przez elementy członkowskie wyliczenia i zawierają wartości, takie jak UnicodeCategory , i , na UnicodeCategory.CurrencySymbol UnicodeCategory.LowercaseLetter UnicodeCategory.SpaceSeparator przykład.

Aby określić kategorię unicode znaku, wywołaj GetUnicodeCategory metodę . Na przykład poniższy przykład wywołuje znak , GetUnicodeCategory aby wyświetlić kategorię Unicode każdego znaku w ciągu. Przykład działa poprawnie tylko wtedy, gdy w wystąpieniu nie ma żadnych par String 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 Example
   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) metoda zależy od kategorii Unicode zgłaszanych GetUnicodeCategory przez CharUnicodeInfo klasę. Począwszy od wersji .NET Framework 4.6.2, znaki Unicode są klasyfikowane na podstawie standardu Unicode w wersji 8.0.0. W wersjach .NET Framework od .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 obiektów, praca z poszczególnymi obiektami nie zawsze ma Char Char znaczenie. Na przykład poniższy przykład konwertuje punkty kodu Unicode reprezentujące liczby od 9 do 9 na jednostki kodu zakodowane w formacie UTF-16. Ponieważ błędnie zrównuje obiekty ze znakami, niedokładnie zgłasza, że Char wynikowy ciąg ma 20 znaków.

using System;

public class Example
{
   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 Example
   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.

Możesz wykonać następujące czynności, aby uniknąć założenia, że Char obiekt reprezentuje pojedynczy znak.

  • Możesz pracować z obiektem w całości, zamiast pracować z jego poszczególnymi znakami w celu String reprezentowania i analizowania zawartości językowej.

  • Możesz użyć funkcji 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
    
  • Klasy można używać StringInfo do pracy z elementami tekstowymi, a nie z poszczególnymi Char obiektami. W poniższym przykładzie użyto obiektu , aby zliczyć liczbę elementów tekstowych w ciągu, który składa się z liczb StringInfo 0–9. Ponieważ uznaje parę zastępczą za pojedynczy znak, prawidłowo zgłasza, że ciąg zawiera dziesięć znaków.

    using System;
    using System.Globalization;
    
    public class Example
    {
       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 Example
       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 zawiera co najmniej jeden znak łączący, możesz wywołać metodę , aby przekonwertować podciąg na pojedynczą jednostkę kodu zakodowaną w formacie String.Normalize UTF-16. Poniższy przykład wywołuje metodę w celu przekonwertowania znaku podstawowego String.Normalize U+0061 (LATIN SMALL LETTER A) i połączenia znaku U+0308 (ŁĄCZENIE DIAERESIS) na U+00E4 (ŁACIŃSKA MAŁA LITERA A Z DIAERESIS).

    using System;
    
    public class Example
    {
       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 Example
       Public Sub Main()
          Dim combining As String = ChrW(&h0061) + ChrW(&h0308)
          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 udostępnia metody porównywania obiektów, konwertowania wartości bieżącego obiektu na obiekt innego typu i określania kategorii Char Char Unicode Char Char obiektu:

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

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

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

Zobacz też Rune typ .
Pobierz kategorię znaku Unicode GetUnicodeCategory

Zobacz też Rune.GetUnicodeCategory.
Określanie, czy znak należy do określonej kategorii Unicode, takiej jak cyfra, litera, znak interpunkcji, znak kontrolny i tak dalej IsControl, IsDigit , , , , , , , IsHighSurrogate , , IsLetter , , , IsLetterOrDigit , IsLower IsLowSurrogate IsNumber IsPunctuation IsSeparator IsSurrogate IsSurrogatePair IsSymbol IsUpper i IsWhiteSpace

Zobacz również odpowiednie metody dla Rune typu.
Konwertowanie Char 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 przypadku Char obiektu ToLower, ToLowerInvariant , ToUpper i ToUpperInvariant

Zobacz również odpowiednie metody dla Rune typu.

Wartości znaków i międzyoptyk

Gdy typ zarządzany, który jest reprezentowany jako jednostka kodu zakodowanego w formacie Unicode UTF-16, jest przekazywany do kodu nieza zarządzania, marshaler międzyopłacowy domyślnie konwertuje znak ustawiony na Char ANSI. Atrybut można zastosować do deklaracji wywołań platformy, a atrybut do deklaracji międzyopłacowej COM, aby kontrolować, który znak jest używany przez typ DllImportAttribute StructLayoutAttribute Char marshaled.

Pola

MaxValue

Reprezentuje największą możliwą wartość Char . To pole jest stałe.

MinValue

Reprezentuje najmniejszą możliwą Char wartość . To pole jest stałe.

Metody

CompareTo(Char)

Porównuje to wystąpienie z określonym obiektem i wskazuje, czy to wystąpienie poprzedza, następuje, czy pojawia się w tej samej pozycji w kolejności sortowania co Char określony Char obiekt.

CompareTo(Object)

Porównuje to wystąpienie z określonym obiektem i wskazuje, czy to wystąpienie poprzedza, następuje, czy pojawia się w tej samej pozycji w kolejności sortowania co określona Object .

ConvertFromUtf32(Int32)

Konwertuje określony punkt kodu Unicode na ciąg zakodowany w formacie UTF-16.

ConvertToUtf32(Char, Char)

Konwertuje wartość pary zastępczej zakodowanej w formacie UTF-16 na punkt kodu Unicode.

ConvertToUtf32(String, Int32)

Konwertuje wartość znaku zakodowanego w formacie UTF-16 lub pary zastępczej w określonej pozycji w ciągu na punkt kodu Unicode.

Equals(Char)

Zwraca wartość, która wskazuje, czy to wystąpienie jest równe określoneowi Char obiektowi.

Equals(Object)

Zwraca wartość wskazującą, czy to wystąpienie jest równe podanemu obiektowi.

GetHashCode()

Zwraca wartość skrótu dla tego wystąpienia.

GetNumericValue(Char)

Konwertuje określony liczbowy znak Unicode na liczbę zmiennoprzecinkową o podwójnej precyzji.

GetNumericValue(String, Int32)

Konwertuje liczbowy znak Unicode w określonej pozycji w określonym ciągu na liczbę zmiennoprzecinkową o podwójnej precyzji.

GetTypeCode()

Zwraca typ TypeCode wartości Char dla .

GetUnicodeCategory(Char)

Kategoryzowanie określonego znaku Unicode na grupę identyfikowaną przez jedną z UnicodeCategory wartości.

GetUnicodeCategory(String, Int32)

Klasyfikuje znak w określonej pozycji w określonym ciągu na grupę identyfikowaną przez jedną z UnicodeCategory wartości.

IsAscii(Char)

Zwraca true wartość , jeśli jest c znakiem ASCII ([ U+0000..U+007F ]).

IsControl(Char)

Wskazuje, czy określony znak Unicode jest kategoryzowany jako znak kontrolny.

IsControl(String, Int32)

Wskazuje, czy znak w określonej pozycji w określonym ciągu jest kategoryzowany jako znak kontrolny.

IsDigit(Char)

Wskazuje, czy określony znak Unicode jest kategoryzowany jako cyfra dziesiętna.

IsDigit(String, Int32)

Wskazuje, czy znak w określonej pozycji w określonym ciągu jest kategoryzowany jako cyfra dziesiętna.

IsHighSurrogate(Char)

Wskazuje, czy określony Char obiekt jest wysokim surogatem.

IsHighSurrogate(String, Int32)

Wskazuje, czy obiekt w określonej pozycji w ciągu jest Char wysokim surogatem.

IsLetter(Char)

Wskazuje, czy określony znak Unicode jest kategoryzowany jako litera Unicode.

IsLetter(String, Int32)

Wskazuje, czy znak w określonej pozycji w określonym ciągu jest skategoryzowany jako litera Unicode.

IsLetterOrDigit(Char)

Wskazuje, czy określony znak Unicode jest kategoryzowany jako litera, czy cyfra dziesiętna.

IsLetterOrDigit(String, Int32)

Wskazuje, czy znak w określonej pozycji w określonym ciągu jest kategoryzowany jako litera, czy cyfra dziesiętna.

IsLower(Char)

Wskazuje, czy określony znak Unicode jest kategoryzowany jako mała litera.

IsLower(String, Int32)

Wskazuje, czy znak w określonej pozycji w określonym ciągu jest kategoryzowany jako mała litera.

IsLowSurrogate(Char)

Wskazuje, czy określony Char obiekt jest niskim surogatem.

IsLowSurrogate(String, Int32)

Wskazuje, czy Char obiekt w określonej pozycji w ciągu jest niskim surogatem.

IsNumber(Char)

Wskazuje, czy określony znak Unicode jest kategoryzowany jako liczba.

IsNumber(String, Int32)

Wskazuje, czy znak w określonej pozycji w określonym ciągu jest kategoryzowany jako liczba.

IsPunctuation(Char)

Wskazuje, czy określony znak Unicode jest kategoryzowany jako znak interpunkcji.

IsPunctuation(String, Int32)

Wskazuje, czy znak w określonej pozycji w określonym ciągu jest kategoryzowany jako znak interpunkcji.

IsSeparator(Char)

Wskazuje, czy określony znak Unicode jest kategoryzowany jako znak separatora.

IsSeparator(String, Int32)

Wskazuje, czy znak w określonej pozycji w określonym ciągu jest kategoryzowany jako znak separatora.

IsSurrogate(Char)

Wskazuje, czy określony znak ma jednostkę kodu zastępczego.

IsSurrogate(String, Int32)

Wskazuje, czy znak w określonej pozycji w określonym ciągu ma jednostkę kodu zastępczego.

IsSurrogatePair(Char, Char)

Wskazuje, czy dwa określone Char obiekty tworzą parę zastępczą.

IsSurrogatePair(String, Int32)

Wskazuje, czy dwa sąsiadujące Char obiekty w określonej pozycji w ciągu tworzą parę zastępczą.

IsSymbol(Char)

Wskazuje, czy określony znak Unicode jest kategoryzowany jako znak symbolu.

IsSymbol(String, Int32)

Wskazuje, czy znak w określonej pozycji w określonym ciągu jest skategoryzowany jako znak symbolu.

IsUpper(Char)

Wskazuje, czy określony znak Unicode jest kategoryzowany jako wielkie litery.

IsUpper(String, Int32)

Wskazuje, czy znak w określonej pozycji w określonym ciągu jest kategoryzowany jako wielkie litery.

IsWhiteSpace(Char)

Wskazuje, czy określony znak Unicode jest kategoryzowany jako biały znak.

IsWhiteSpace(String, Int32)

Wskazuje, czy znak w określonej pozycji w określonym ciągu jest skategoryzowany jako biały znak.

Parse(String)

Konwertuje wartość określonego ciągu na równoważny znak Unicode.

ToLower(Char)

Konwertuje wartość znaku Unicode na równoważnik małych liter.

ToLower(Char, CultureInfo)

Konwertuje wartość określonego znaku Unicode na równoważnik małych liter przy użyciu określonych informacji o formatowaniu specyficznych dla kultury.

ToLowerInvariant(Char)

Konwertuje wartość znaku Unicode na równoważnik małych liter przy użyciu reguł wielkości liter niezmiennej kultury.

ToString()

Konwertuje wartość tego wystąpienia na jego równoważną reprezentację w postaci ciągu.

ToString(Char)

Konwertuje określony znak Unicode na równoważną reprezentację ciągu.

ToString(IFormatProvider)

Konwertuje wartość tego wystąpienia na równoważną reprezentację ciągu przy użyciu określonych informacji o formacie specyficznym dla kultury.

ToUpper(Char)

Konwertuje wartość znaku Unicode na równoważnik wielkich liter.

ToUpper(Char, CultureInfo)

Konwertuje wartość określonego znaku Unicode na równoważnik wielkich liter przy użyciu określonych informacji o formatowaniu specyficznych dla kultury.

ToUpperInvariant(Char)

Konwertuje wartość znaku Unicode na równoważnik wielkich liter przy użyciu reguł wielkości liter niezmiennej kultury.

TryParse(String, Char)

Konwertuje wartość określonego ciągu na równoważny znak Unicode. Zwracany kod wskazuje, czy konwersja zakończyła się powodzeniem, czy niepowodzeniem.

Jawne implementacje interfejsu

IComparable.CompareTo(Object)

Porównuje bieżące wystąpienie z innym obiektem tego samego typu i zwraca liczbę całkowitą, która wskazuje, czy bieżące wystąpienie poprzedza, następuje po lub występuje w tym samym położeniu, co inny obiekt w porządku sortowania.

IConvertible.GetTypeCode()

Zwraca wartość TypeCode dla tego wystąpienia.

IConvertible.ToBoolean(IFormatProvider)

Uwaga Ta konwersja nie jest obsługiwana. Próba w tym celu zgłasza wyjątek InvalidCastException .

IConvertible.ToByte(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToByte(IFormatProvider) .

IConvertible.ToChar(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToChar(IFormatProvider) .

IConvertible.ToDateTime(IFormatProvider)

Uwaga Ta konwersja nie jest obsługiwana. Próba w tym celu zgłasza wyjątek InvalidCastException .

IConvertible.ToDecimal(IFormatProvider)

Uwaga Ta konwersja nie jest obsługiwana. Próba w tym celu zgłasza wyjątek InvalidCastException .

IConvertible.ToDouble(IFormatProvider)

Uwaga Ta konwersja nie jest obsługiwana. Próba w tym celu zgłasza wyjątek InvalidCastException .

IConvertible.ToInt16(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToInt16(IFormatProvider) .

IConvertible.ToInt32(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToInt32(IFormatProvider) .

IConvertible.ToInt64(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToInt64(IFormatProvider) .

IConvertible.ToSByte(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToSByte(IFormatProvider) .

IConvertible.ToSingle(IFormatProvider)

Uwaga Ta konwersja nie jest obsługiwana. Próba w tym celu zgłasza wyjątek InvalidCastException .

IConvertible.ToString(IFormatProvider)

Konwertuje wartość tego wystąpienia na równoważny ciąg przy użyciu określonych informacji o formatowaniu specyficznych dla kultury.

IConvertible.ToType(Type, IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToType(Type, IFormatProvider) .

IConvertible.ToUInt16(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToUInt16(IFormatProvider) .

IConvertible.ToUInt32(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToUInt32(IFormatProvider) .

IConvertible.ToUInt64(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToUInt64(IFormatProvider) .

IFormattable.ToString(String, IFormatProvider)

Formatuje wartość bieżącego wystąpienia przy użyciu określonego formatu.

ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Próbuje sformatować wartość bieżącego wystąpienia do podanego zakresu znaków.

Dotyczy

Bezpieczeństwo wątkowe

Wszystkie elementy członkowskie tego typu są bezpieczne wątkowo. Elementy członkowskie, które na pierwszy rzut oka modyfikują stan wystąpienia, w rzeczywistości zwracają nowe wystąpienie zainicjowane z nową wartością. Podobnie jak w przypadku innych typów odczytywanie i zapisywanie w udostępnionej zmiennej, która zawiera wystąpienie tego typu, musi być chronione przez blokadę w celu zagwarantowania bezpieczeństwa wątków.

Zobacz też