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 : IAdditionOperators<char, char, char>, IAdditiveIdentity<char, char>, IBinaryInteger<char>, IBinaryNumber<char>, IBitwiseOperators<char, char, char>, IComparable<char>, IComparisonOperators<char, char>, IConvertible, IDecrementOperators<char>, IDivisionOperators<char, char, char>, IEqualityOperators<char, char>, IEquatable<char>, IIncrementOperators<char>, IMinMaxValue<char>, IModulusOperators<char, char, char>, IMultiplicativeIdentity<char, char>, IMultiplyOperators<char, char, char>, INumber<char>, IParseable<char>, IShiftOperators<char, char>, ISpanParseable<char>, ISubtractionOperators<char, char, char>, IUnaryNegationOperators<char, char>, IUnaryPlusOperators<char, char>, IUnsignedNumber<char>
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 readonly struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
public readonly struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>, ISpanFormattable
public readonly struct Char : IAdditionOperators<char,char,char>, IAdditiveIdentity<char,char>, IBinaryInteger<char>, IBinaryNumber<char>, IBitwiseOperators<char,char,char>, IComparable<char>, IComparisonOperators<char,char>, IConvertible, IDecrementOperators<char>, IDivisionOperators<char,char,char>, IEqualityOperators<char,char>, IEquatable<char>, IIncrementOperators<char>, IMinMaxValue<char>, IModulusOperators<char,char,char>, IMultiplicativeIdentity<char,char>, IMultiplyOperators<char,char,char>, INumber<char>, IParseable<char>, IShiftOperators<char,char>, ISpanParseable<char>, ISubtractionOperators<char,char,char>, IUnaryNegationOperators<char,char>, IUnaryPlusOperators<char,char>, IUnsignedNumber<char>
[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
type char = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable
    interface IBinaryInteger<char>
    interface IBinaryNumber<char>
    interface IBitwiseOperators<char, char, char>
    interface INumber<char>
    interface IAdditionOperators<char, char, char>
    interface IAdditiveIdentity<char, char>
    interface IComparisonOperators<char, char>
    interface IEqualityOperators<char, char>
    interface IDecrementOperators<char>
    interface IDivisionOperators<char, char, char>
    interface IIncrementOperators<char>
    interface IModulusOperators<char, char, char>
    interface IMultiplicativeIdentity<char, char>
    interface IMultiplyOperators<char, char, char>
    interface IParseable<char>
    interface ISpanParseable<char>
    interface ISubtractionOperators<char, char, char>
    interface IUnaryNegationOperators<char, char>
    interface IUnaryPlusOperators<char, char>
    interface IShiftOperators<char, char>
    interface IMinMaxValue<char>
    interface IUnsignedNumber<char>
[<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 IAdditionOperators(Of Char, Char, Char), IAdditiveIdentity(Of Char, Char), IBinaryInteger(Of Char), IBinaryNumber(Of Char), IBitwiseOperators(Of Char, Char, Char), IComparable(Of Char), IComparisonOperators(Of Char, Char), IConvertible, IDecrementOperators(Of Char), IDivisionOperators(Of Char, Char, Char), IEqualityOperators(Of Char, Char), IEquatable(Of Char), IIncrementOperators(Of Char), IMinMaxValue(Of Char), IModulusOperators(Of Char, Char, Char), IMultiplicativeIdentity(Of Char, Char), IMultiplyOperators(Of Char, Char, Char), INumber(Of Char), IParseable(Of Char), IShiftOperators(Of Char, Char), ISpanParseable(Of Char), ISubtractionOperators(Of Char, Char, Char), IUnaryNegationOperators(Of Char, Char), IUnaryPlusOperators(Of Char, Char), IUnsignedNumber(Of Char)
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 pliku 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

Platforma .NET używa Char struktury do reprezentowania punktów kodu Unicode przy użyciu kodowania UTF-16. Wartość Char obiektu to 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 poniższych sekcjach opisano relację między obiektem Char a znakiem i omówiono niektóre typowe zadania wykonywane z wystąpieniami Char . 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

Obiekt String jest sekwencyjną kolekcją Char struktur, która reprezentuje 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, Char po którym następuje obiekt, którego jednostka kodu to U+0308. (Znak ä można również zdefiniować za pomocą pojedynczego Char obiektu, 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 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). 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 ÓSMEJ NOTATKI SYMBOLU MUZYCZNEgo. Ponieważ kodowanie UTF-16 ma tylko 16 bitów, znaki poza BMP są reprezentowane przez pary zastępcze w UTF-16. Poniższy przykład ilustruje, że odpowiednik UTF-32 U+1D160, znak MUSICAL SYMBOL ÓSMEJ NOTATKI, 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ą; niski zakres zastępczych 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 zastępcza należy do kategorii Unicode. Na platformie .NET kategorie Unicode są reprezentowane przez elementy członkowskie wyliczenia UnicodeCategory i zawierają wartości, takie jak UnicodeCategory.CurrencySymbol, UnicodeCategory.LowercaseLetteri UnicodeCategory.SpaceSeparator, na przykład.

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 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 (U+0000 do U+00FF) GetUnicodeCategory metoda zależy od kategorii Unicode zgłoszonych przez klasę CharUnicodeInfo . Począwszy od .NET Framework 4.6.2, znaki Unicode są klasyfikowane na podstawie standardu Unicode w wersji 8.0.0. W wersjach .NET Framework z .NET Framework 4 do .NET Framework 4.6.1 są 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 znaczenie dla pracy z poszczególnymi Char obiektami. Na przykład poniższy przykład konwertuje punkty kodu Unicode reprezentujące liczby egejskie od 9 do zakodowanych jednostek kodu UTF-16. Ponieważ błędnie równa Char obiekty znakami, niedokładnie zgłasza, że 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 String w całości, zamiast pracować z poszczególnymi znakami, aby reprezentować i analizować zawartość językową.

  • Możesz użyć String.EnumerateRunes polecenia , 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ę można używać StringInfo do pracy z elementami tekstowymi zamiast poszczególnych Char obiektów. W poniższym przykładzie użyto StringInfo obiektu do zliczenia liczby elementów tekstowych w ciągu składającym się z liczb egejskich od zera do dziewięciu. Ponieważ uwzględnia ona parę zastępczą pojedynczego znaku, poprawnie 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 zawierający co najmniej jeden znak łączący, możesz wywołać String.Normalize metodę w celu przekonwertowania podciągów na pojedynczą zakodowaną jednostkę kodu UTF-16. Poniższy przykład wywołuje metodę String.Normalize w celu przekonwertowania znaku podstawowego U+0061 (ŁACIŃSKA MAŁA LITERA A) i połączenia znaku U+0308 (ŁĄCZENIE DIAERESIS) do U+00E4 (MAŁA LITERA ŁACIŃSKA A Z DIAEREZĄ).

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

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

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

W przypadku 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. IsControlIsDigit, IsHighSurrogate, IsLetterOrDigitIsLowSurrogateIsNumberIsPunctuationIsLowerIsLetterIsSurrogateIsSurrogatePairIsSeparatorIsSymbol, i IsUpperIsWhiteSpace

Zobacz również odpowiednie metody w typie Rune .
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 w typie Rune .

Wartości znaków i współdziałanie

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

Pola

MaxValue

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

MinValue

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

Metody

CompareTo(Char)

Porównuje to wystąpienie z określonym Char obiektem i wskazuje, czy to wystąpienie poprzedza, następuje lub pojawia się w tej samej pozycji w kolejności sortowania co 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 kolejności sortowania, co określone Object.

ConvertFromUtf32(Int32)

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

ConvertToUtf32(Char, Char)

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

ConvertToUtf32(String, Int32)

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

Equals(Char)

Zwraca wartość wskazującą, czy to wystąpienie jest równe określonemu 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 znak liczbowy Unicode na liczbę zmiennoprzecinkową o podwójnej precyzji.

GetNumericValue(String, Int32)

Konwertuje numeryczny znak Unicode na określoną pozycję w określonym ciągu na liczbę zmiennoprzecinkową o podwójnej precyzji.

GetTypeCode()

Zwraca wartość TypeCode typu dla wartości Char.

GetUnicodeCategory(Char)

Kategoryzuje określony znak Unicode w grupie identyfikowanej przez jedną z UnicodeCategory wartości.

GetUnicodeCategory(String, Int32)

Kategoryzuje znak na określonej pozycji w określonym ciągu w grupie identyfikowanej przez jedną z UnicodeCategory wartości.

IsAscii(Char)

Zwraca true wartość , jeśli c jest 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 na określonej pozycji w określonym ciągu jest kategoryzowany jako znak kontrolny.

IsDigit(Char)

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

IsDigit(String, Int32)

Wskazuje, czy znak na 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 Char obiekt na określonej pozycji w ciągu jest wysokim surogatem.

IsLetter(Char)

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

IsLetter(String, Int32)

Wskazuje, czy znak na określonej pozycji w określonym ciągu jest kategoryzowany 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 na 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 zastępcą.

IsLowSurrogate(String, Int32)

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

IsNumber(Char)

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

IsNumber(String, Int32)

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

IsPunctuation(Char)

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

IsPunctuation(String, Int32)

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

IsSeparator(Char)

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

IsSeparator(String, Int32)

Wskazuje, czy znak na 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 na 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 na 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 na określonej pozycji w określonym ciągu jest kategoryzowany jako znak symbolu.

IsUpper(Char)

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

IsUpper(String, Int32)

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

IsWhiteSpace(Char)

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

IsWhiteSpace(String, Int32)

Wskazuje, czy znak na określonej pozycji w określonym ciągu jest kategoryzowany 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 jego małe litery równoważne.

ToLower(Char, CultureInfo)

Konwertuje wartość określonego znaku Unicode na jego małe litery równoważne przy użyciu określonych informacji o formatowaniu specyficznym dla kultury.

ToLowerInvariant(Char)

Konwertuje wartość znaku Unicode na jego małe litery równoważne 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 jego wielkie litery równoważne.

ToUpper(Char, CultureInfo)

Konwertuje wartość określonego znaku Unicode na jego wielkie litery równoważne przy użyciu określonych informacji o formatowaniu specyficznym dla kultury.

ToUpperInvariant(Char)

Konwertuje wartość znaku Unicode na jego wielkie litery przy użyciu reguł wielkości liter niezmiennej kultury.

TryParse(String, Char)

Konwertuje wartość określonego ciągu na równoważny znak Unicode. Kod powrotu wskazuje, czy konwersja zakończyła się pomyślnie, czy nie powiodła się.

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 wykonania tej czynności zgłasza błąd InvalidCastException.

IConvertible.ToByte(IFormatProvider)

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

IConvertible.ToChar(IFormatProvider)

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

IConvertible.ToDateTime(IFormatProvider)

Uwaga Ta konwersja nie jest obsługiwana. Próba wykonania tej czynności zgłasza błąd InvalidCastException.

IConvertible.ToDecimal(IFormatProvider)

Uwaga Ta konwersja nie jest obsługiwana. Próba wykonania tej czynności zgłasza błąd InvalidCastException.

IConvertible.ToDouble(IFormatProvider)

Uwaga Ta konwersja nie jest obsługiwana. Próba wykonania tej czynności zgłasza błąd InvalidCastException.

IConvertible.ToInt16(IFormatProvider)

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

IConvertible.ToInt32(IFormatProvider)

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

IConvertible.ToInt64(IFormatProvider)

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

IConvertible.ToSByte(IFormatProvider)

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

IConvertible.ToSingle(IFormatProvider)

Uwaga Ta konwersja nie jest obsługiwana. Próba wykonania tej czynności zgłasza błąd InvalidCastException.

IConvertible.ToString(IFormatProvider)

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

IConvertible.ToType(Type, IFormatProvider)

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

IConvertible.ToUInt16(IFormatProvider)

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

IConvertible.ToUInt32(IFormatProvider)

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

IConvertible.ToUInt64(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, 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 w podanym zakresie 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ż