Char Struktura

Definice

Představuje znak jako jednotku kódu 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<char>, IConvertible, IEquatable<char>, IParsable<char>, ISpanParsable<char>, System::Numerics::IAdditionOperators<char, char, char>, System::Numerics::IAdditiveIdentity<char, char>, System::Numerics::IBinaryInteger<char>, System::Numerics::IBinaryNumber<char>, System::Numerics::IBitwiseOperators<char, char, char>, System::Numerics::IComparisonOperators<char, char, bool>, System::Numerics::IDecrementOperators<char>, System::Numerics::IDivisionOperators<char, char, char>, System::Numerics::IEqualityOperators<char, char, bool>, System::Numerics::IIncrementOperators<char>, System::Numerics::IMinMaxValue<char>, System::Numerics::IModulusOperators<char, char, char>, System::Numerics::IMultiplicativeIdentity<char, char>, System::Numerics::IMultiplyOperators<char, char, char>, System::Numerics::INumber<char>, System::Numerics::INumberBase<char>, System::Numerics::IShiftOperators<char, int, char>, System::Numerics::ISubtractionOperators<char, char, char>, System::Numerics::IUnaryNegationOperators<char, char>, System::Numerics::IUnaryPlusOperators<char, char>, System::Numerics::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 : IComparable<char>, IConvertible, IEquatable<char>, IParsable<char>, ISpanParsable<char>, System.Numerics.IAdditionOperators<char,char,char>, System.Numerics.IAdditiveIdentity<char,char>, System.Numerics.IBinaryInteger<char>, System.Numerics.IBinaryNumber<char>, System.Numerics.IBitwiseOperators<char,char,char>, System.Numerics.IComparisonOperators<char,char,bool>, System.Numerics.IDecrementOperators<char>, System.Numerics.IDivisionOperators<char,char,char>, System.Numerics.IEqualityOperators<char,char,bool>, System.Numerics.IIncrementOperators<char>, System.Numerics.IMinMaxValue<char>, System.Numerics.IModulusOperators<char,char,char>, System.Numerics.IMultiplicativeIdentity<char,char>, System.Numerics.IMultiplyOperators<char,char,char>, System.Numerics.INumber<char>, System.Numerics.INumberBase<char>, System.Numerics.IShiftOperators<char,int,char>, System.Numerics.ISubtractionOperators<char,char,char>, System.Numerics.IUnaryNegationOperators<char,char>, System.Numerics.IUnaryPlusOperators<char,char>, System.Numerics.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 IFormattable
    interface IParsable<char>
    interface ISpanFormattable
    interface ISpanParsable<char>
    interface IAdditionOperators<char, char, char>
    interface IAdditiveIdentity<char, char>
    interface IBinaryInteger<char>
    interface IBinaryNumber<char>
    interface IBitwiseOperators<char, char, char>
    interface IComparisonOperators<char, char, bool>
    interface IEqualityOperators<char, char, bool>
    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 INumber<char>
    interface INumberBase<char>
    interface ISubtractionOperators<char, char, char>
    interface IUnaryNegationOperators<char, char>
    interface IUnaryPlusOperators<char, char>
    interface IShiftOperators<char, int, 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, Boolean), IConvertible, IDecrementOperators(Of Char), IDivisionOperators(Of Char, Char, Char), IEqualityOperators(Of Char, Char, Boolean), 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), INumberBase(Of Char), IParsable(Of Char), IShiftOperators(Of Char, Integer, Char), ISpanParsable(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)
Dědičnost
Atributy
Implementuje

Příklady

Následující příklad kódu ukazuje některé z metod v 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

Poznámky

.NET používá strukturu k reprezentaci Char bodů kódu Unicode pomocí kódování UTF-16. Hodnota objektu Char je jeho 16bitová číselná (řadová) hodnota.

Pokud neznáte kódování Unicode, skalární hodnoty, body kódu, náhradní páry, UTF-16 a Rune typ, přečtěte si téma Úvod do kódování znaků v .NET.

Následující části zkoumají vztah mezi objektem Char a znakem a probírají některé běžné úlohy prováděné s Char instancemi. Doporučujeme zvážit Rune typ uvedený v .NET Core 3.0 jako alternativu k Char provádění některých z těchto úloh.

Objekty Char, znaky Unicode a řetězce

Objekt String je sekvenční kolekce Char struktur, která představuje textový řetězec. Většina znaků Unicode může být reprezentována jedním Char objektem, ale znak, který je zakódován jako základní znak, náhradní pár nebo kombinování sekvence znaků, je reprezentován více Char objekty. Z tohoto důvodu Char není struktura v objektu String nutně ekvivalentní jednomu znaku Unicode.

Několik 16bitových jednotek kódu se používá k reprezentaci jednotlivých znaků Unicode v následujících případech:

  • Glyfy, které se mohou skládat z jednoho znaku nebo základního znaku následovaného jedním nebo více kombinačními znaky. Například znak ä je reprezentován objektem Char , jehož kódová jednotka je U+0061 následovaný objektem Char , jehož jednotka kódu je U+0308. (Znak ä může být také definován jedním Char objektem, který má jednotku kódu U+00E4.) Následující příklad ukazuje, že znak ä se skládá ze dvou Char objektů.

    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:
    '       ä
    
  • Znaky mimo základní vícejazyčnou rovinu unicode (BMP). Unicode podporuje šestnáct rovin kromě BMP, který představuje rovinu 0. Bod kódu Unicode je v UTF-32 reprezentován 21bitovou hodnotou, která obsahuje rovinu. Například U+1D160 představuje znak HUDEBNÍ SYMBOL OSMÁ POZNÁMKA. Vzhledem k tomu, že kódování UTF-16 má pouze 16 bitů, jsou znaky mimo BMP reprezentovány náhradními páry v UTF-16. Následující příklad ukazuje, že ekvivalent UTF-32 pro U+1D160, znak HUDEBNÍ SYMBOL OSMÁ POZNÁMKA, je U+D834 U+DD60. U+D834 je vysoký náhradní; Vysoké náhrady jsou v rozsahu od U+D800 až po U+DBFF. U+DD60 je nízký náhradník; nízký rozsah náhradních prostředků od U+DC00 až po 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
    

Znaky a kategorie znaků

Každý znak unicode nebo platný náhradní pár patří do kategorie Unicode. V .NET jsou kategorie Unicode reprezentovány členy výčtu UnicodeCategory a zahrnují například hodnoty UnicodeCategory.CurrencySymbol, UnicodeCategory.LowercaseLettera UnicodeCategory.SpaceSeparator.

Chcete-li určit unicode kategorie znaku, zavolejte metodu GetUnicodeCategory . Například následující příklad volá, GetUnicodeCategory aby se zobrazila kategorie Unicode každého znaku v řetězci. Příklad funguje správně pouze v případě, že instance String neobsahuje žádné náhradní páry.

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

Interně pro znaky mimo rozsah ASCII (U+0000 až U+00FF) GetUnicodeCategory závisí metoda na kategoriích Unicode hlášených CharUnicodeInfo třídou. Počínaje rozhraním .NET Framework 4.6.2 jsou znaky Unicode klasifikovány na základě standardu Unicode verze 8.0.0. Ve verzích rozhraní .NET Framework z rozhraní .NET Framework 4 až .NET Framework 4.6.1 jsou klasifikovány na základě standardu Unicode verze 6.3.0.

Znaky a textové prvky

Vzhledem k tomu, že jeden znak může být reprezentován více Char objekty, není vždy smysluplné pracovat s jednotlivými Char objekty. Následující příklad například převede body kódu Unicode, které představují egejské čísla nula až 9, na jednotky kódu kódování UTF-16. Protože chybně přirovnává Char objekty ke znakům, nepřesně hlásí, že výsledný řetězec má 20 znaků.

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.

Následujícím postupem se můžete vyhnout předpokladu Char , že objekt představuje jeden znak:

  • S objektem String můžete pracovat jako celek a nemusíte pracovat s jeho jednotlivými znaky a reprezentovat a analyzovat lingvistický obsah.

  • Můžete použít String.EnumerateRunes , jak je znázorněno v následujícím příkladu:

    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
    
  • Třídu můžete použít StringInfo k práci s textovými prvky místo s jednotlivými Char objekty. Následující příklad používá StringInfo objekt k spočítání počtu textových prvků v řetězci, který se skládá z egejských čísel nula až devět. Vzhledem k tomu, že náhradní pár považuje za jeden znak, správně hlásí, že řetězec obsahuje deset znaků.

    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.
    
  • Pokud řetězec obsahuje základní znak, který obsahuje jeden nebo více kombinujících znaků, můžete voláním String.Normalize metody převést podřetězcec na jednu kódovou jednotku kódování UTF-16. Následující příklad volá metodu String.Normalize pro převod základního znaku U+0061 (MALÉ PÍSMENO LATINKY A) a kombinování znaku U+0308 (COMBINING DIAERESIS) na U+00E4 (MALÉ PÍSMENO LATINKY A S 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)
    

Běžné operace

Struktura Char poskytuje metody pro porovnání Char objektů, převod hodnoty aktuálního Char objektu na objekt jiného typu a určení kategorie Unicode objektu Char :

Akce Použijte tyto metody.System.Char
Porovnání Char objektů CompareTo a Equals
Převod bodu kódu na řetězec ConvertFromUtf32

Viz také Rune typ.
Převod objektu Char nebo náhradní dvojice Char objektů na bod kódu Jeden znak: Convert.ToInt32(Char)

Náhradní pár nebo znak v řetězci: Char.ConvertToUtf32

Viz také Rune typ.
Získání kategorie znaku v kódování Unicode GetUnicodeCategory

Viz také Rune.GetUnicodeCategory.
Určení, jestli se znak nachází v určité kategorii unicode, jako je číslice, písmeno, interpunkce, řídicí znak atd. IsControl, , IsDigitIsHighSurrogate, IsLetter, IsLetterOrDigit, IsLower, IsLowSurrogate, IsNumber, IsPunctuation, IsSeparator, IsSurrogate, , IsSurrogatePair, IsSymbol, , IsUpper, aIsWhiteSpace

Viz také odpovídající metody pro typ Rune .
Převod objektu Char , který představuje číslo, na typ číselné hodnoty GetNumericValue

Viz také Rune.GetNumericValue.
Převod znaku v řetězci na Char objekt Parse a TryParse
Převod objektu CharString na objekt ToString
Změna velikosti písmen objektu Char ToLower, ToLowerInvariant, ToUppera ToUpperInvariant

Viz také odpovídající metody pro typ Rune .

Hodnoty znaků a spolupráce

Pokud se spravovaný Char typ, který je reprezentovaný jako jednotka kódu kódování Unicode UTF-16, předá nespravovanému kódu, zařazovací zařazování interop ve výchozím nastavení převede znakovou sadu na ANSI. Atribut můžete použít DllImportAttribute u deklarací volání platformy a StructLayoutAttribute atributu pro deklaraci zprostředkovatele komunikace COM, abyste mohli určit, kterou znakovou sadu používá zařazovaný Char typ.

Pole

MaxValue

Představuje největší možnou hodnotu objektu Char. Toto pole je konstantní.

MinValue

Představuje nejmenší možnou hodnotu objektu Char. Toto pole je konstantní.

Metody

CompareTo(Char)

Porovná tuto instanci se zadaným Char objektem a určuje, zda tato instance předchází, následuje nebo se zobrazuje ve stejné pozici v pořadí řazení jako zadaný Char objekt.

CompareTo(Object)

Porovná tuto instanci se zadaným objektem a určuje, zda tato instance předchází, následuje nebo se zobrazuje ve stejné pozici v pořadí řazení jako zadaný Objectobjekt .

ConvertFromUtf32(Int32)

Převede zadaný bod kódu Unicode na řetězec s kódováním UTF-16.

ConvertToUtf32(Char, Char)

Převede hodnotu náhradní dvojice kódování UTF-16 na bod kódu Unicode.

ConvertToUtf32(String, Int32)

Převede hodnotu znaku kódování UTF-16 nebo náhradní dvojice na zadané pozici v řetězci na bod kódu Unicode.

Equals(Char)

Vrátí hodnotu, která označuje, zda se tato instance rovná zadanému Char objektu.

Equals(Object)

Vrací hodnotu, která určuje, zda je tato instance rovna zadanému objektu.

GetHashCode()

Vrátí hodnotu hash pro tuto instanci.

GetNumericValue(Char)

Převede zadaný číselný znak unicode na číslo s plovoucí desetinou čárkou s dvojitou přesností.

GetNumericValue(String, Int32)

Převede číselný znak Unicode na zadané pozici v zadaném řetězci na číslo s plovoucí desetinnou čárkou s dvojitou přesností.

GetTypeCode()

TypeCode Vrátí hodnotu pro typ Charhodnoty .

GetUnicodeCategory(Char)

Kategorizuje zadaný znak unicode do skupiny identifikované jednou z UnicodeCategory hodnot.

GetUnicodeCategory(String, Int32)

Kategorizuje znak na zadané pozici v zadaném řetězci do skupiny identifikované jednou z UnicodeCategory hodnot.

IsAscii(Char)

Vrátí, true pokud c je znak ASCII ([ U+0000..U+007F ]).

IsAsciiDigit(Char)

Označuje, zda je znak zařazen do kategorií jako číslice ASCII.

IsAsciiHexDigit(Char)

Určuje, zda je znak zařazen do kategorie šestnáctkové číslice ASCII.

IsAsciiHexDigitLower(Char)

Určuje, zda je znak zařazen do kategorií jako malá šestnáctková číslice ASCII.

IsAsciiHexDigitUpper(Char)

Určuje, zda je znak zařazen do kategorií jako šestnáctková číslice ASCII s velkými písmeny.

IsAsciiLetter(Char)

Určuje, zda je znak zařazen do kategorií jako písmeno ASCII.

IsAsciiLetterLower(Char)

Označuje, zda je znak zařazen do kategorií jako písmeno ASCII s malými písmeny.

IsAsciiLetterOrDigit(Char)

Označuje, zda je znak zařazen do kategorií jako písmeno nebo číslice ASCII.

IsAsciiLetterUpper(Char)

Určuje, zda je znak zařazen do kategorií jako velké písmeno ASCII.

IsBetween(Char, Char, Char)

Určuje, zda se znak nachází v zadaném rozsahu včetně.

IsControl(Char)

Určuje, zda je zadaný znak unicode zařazen do kategorie jako řídicí znak.

IsControl(String, Int32)

Určuje, zda je znak na zadané pozici v zadaném řetězci zařazen jako řídicí znak.

IsDigit(Char)

Určuje, zda je zadaný znak unicode zařazen do kategorie desetinná číslice.

IsDigit(String, Int32)

Určuje, zda je znak na zadané pozici v zadaném řetězci zařazen do kategorie desetinná číslice.

IsHighSurrogate(Char)

Určuje, zda je zadaný Char objekt vysokou náhradou.

IsHighSurrogate(String, Int32)

Určuje, zda Char objekt na zadané pozici v řetězci je vysoká náhradní.

IsLetter(Char)

Určuje, zda je zadaný znak Unicode zařazen do kategorií jako písmeno unicode.

IsLetter(String, Int32)

Určuje, zda je znak na zadané pozici v zadaném řetězci zařazen do kategorií jako písmeno Unicode.

IsLetterOrDigit(Char)

Určuje, zda je zadaný znak unicode zařazen do kategorií jako písmeno nebo desetinná číslice.

IsLetterOrDigit(String, Int32)

Určuje, zda je znak na zadané pozici v zadaném řetězci zařazen do kategorie písmeno nebo desetinná číslice.

IsLower(Char)

Určuje, zda je zadaný znak unicode zařazen do kategorií jako malé písmeno.

IsLower(String, Int32)

Určuje, zda je znak na zadané pozici v zadaném řetězci zařazen do kategorií jako malé písmeno.

IsLowSurrogate(Char)

Určuje, zda je zadaný Char objekt nízký náhradní.

IsLowSurrogate(String, Int32)

Určuje, zda Char objekt na zadané pozici v řetězci je nízký náhradní.

IsNumber(Char)

Určuje, zda je zadaný znak Unicode zařazen do kategorií jako číslo.

IsNumber(String, Int32)

Určuje, zda je znak na zadané pozici v zadaném řetězci zařazen do kategorie číslo.

IsPunctuation(Char)

Určuje, zda je zadaný znak unicode zařazen do kategorií jako interpunkční znaménko.

IsPunctuation(String, Int32)

Určuje, zda je znak na zadané pozici v zadaném řetězci zařazen jako interpunkční znaménko.

IsSeparator(Char)

Určuje, zda je zadaný znak unicode zařazen do kategorie jako znak oddělovače.

IsSeparator(String, Int32)

Určuje, zda je znak na zadané pozici v zadaném řetězci kategorizován jako znak oddělovače.

IsSurrogate(Char)

Určuje, zda zadaný znak má náhradní jednotku kódu.

IsSurrogate(String, Int32)

Určuje, zda má znak na zadané pozici v zadaném řetězci náhradní jednotku kódu.

IsSurrogatePair(Char, Char)

Určuje, zda dva zadané Char objekty tvoří náhradní dvojici.

IsSurrogatePair(String, Int32)

Určuje, zda dva sousední Char objekty na zadané pozici v řetězci tvoří náhradní dvojici.

IsSymbol(Char)

Určuje, zda je zadaný znak unicode zařazen do kategorií jako znak symbolu.

IsSymbol(String, Int32)

Určuje, zda je znak na zadané pozici v zadaném řetězci kategorizován jako znak symbolu.

IsUpper(Char)

Určuje, zda je zadaný znak unicode zařazen do kategorií jako velké písmeno.

IsUpper(String, Int32)

Určuje, zda je znak na zadané pozici v zadaném řetězci zařazen do kategorií jako velké písmeno.

IsWhiteSpace(Char)

Určuje, zda je zadaný znak unicode zařazen do kategorie prázdných znaků.

IsWhiteSpace(String, Int32)

Určuje, zda je znak na zadané pozici v zadaném řetězci zařazen do kategorie prázdných znaků.

Parse(String)

Převede hodnotu zadaného řetězce na jeho ekvivalentní znak Unicode.

ToLower(Char)

Převede hodnotu znaku Unicode na jeho ekvivalent s malými písmeny.

ToLower(Char, CultureInfo)

Převede hodnotu zadaného znaku Unicode na jeho ekvivalent malými písmeny pomocí zadané informace formátování specifické pro jazykovou verzi.

ToLowerInvariant(Char)

Převede hodnotu znaku Unicode na jeho ekvivalent malých písmen pomocí pravidel pro vkládání velkých písmen invariantní jazykové verze.

ToString()

Převede hodnotu této instance na její odpovídající řetězcovou reprezentaci.

ToString(Char)

Převede zadaný znak Unicode na jeho ekvivalentní řetězcovou reprezentaci.

ToString(IFormatProvider)

Převede hodnotu této instance na ekvivalentní řetězcovou reprezentaci pomocí zadané informace o formátu specifické pro jazykovou verzi.

ToUpper(Char)

Převede hodnotu znaku Unicode na jeho ekvivalent s velkými písmeny.

ToUpper(Char, CultureInfo)

Převede hodnotu zadaného znaku Unicode na jeho ekvivalent s velkými písmeny pomocí zadané informace formátování specifické pro jazykovou verzi.

ToUpperInvariant(Char)

Převede hodnotu znaku Unicode na jeho ekvivalent velkých písmen pomocí pravidel pro velká písmena invariantní jazykové verze.

TryParse(String, Char)

Převede hodnotu zadaného řetězce na jeho ekvivalentní znak Unicode. Návratový kód označuje, jestli byl převod úspěšný nebo neúspěšný.

Explicitní implementace rozhraní

IBinaryInteger<Char>.GetByteCount()

Získá počet bajtů, které budou zapsány jako součást .TryWriteLittleEndian(Span<Byte>, Int32)

IBinaryInteger<Char>.GetShortestBitLength()

Získá délku, v bitech, nejkratší dvě reprezentace komplementu aktuální hodnoty.

IBinaryInteger<Char>.TryWriteBigEndian(Span<Byte>, Int32)

Pokusí se zapsat aktuální hodnotu do daného rozsahu ve formátu big-endian.

IBinaryInteger<Char>.TryWriteLittleEndian(Span<Byte>, Int32)

Pokusí se zapsat aktuální hodnotu do daného rozsahu ve formátu little-endian.

IComparable.CompareTo(Object)

Porovná aktuální instanci s jiným objektem stejného typu a vrátí celé číslo udávající, zda aktuální instance předchází, následuje nebo se vyskytuje ve stejné pozici v pořadí řazení jako druhý objekt.

IConvertible.GetTypeCode()

Vrátí hodnotu TypeCode pro tuto instanci.

IConvertible.ToBoolean(IFormatProvider)

Poznámka Tento převod není podporován. Když se o to pokusíte, vyvolá se .InvalidCastException

IConvertible.ToByte(IFormatProvider)

Popis tohoto člena najdete v tématu ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider)

Popis tohoto člena najdete v tématu ToChar(IFormatProvider).

IConvertible.ToDateTime(IFormatProvider)

Poznámka Tento převod není podporován. Když se o to pokusíte, vyvolá se .InvalidCastException

IConvertible.ToDecimal(IFormatProvider)

Poznámka Tento převod není podporován. Když se o to pokusíte, vyvolá se .InvalidCastException

IConvertible.ToDouble(IFormatProvider)

Poznámka Tento převod není podporován. Když se o to pokusíte, vyvolá se .InvalidCastException

IConvertible.ToInt16(IFormatProvider)

Popis tohoto člena najdete v tématu ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider)

Popis tohoto člena najdete v tématu ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider)

Popis tohoto člena najdete v tématu ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider)

Popis tohoto člena najdete v tématu ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider)

Poznámka Tento převod není podporován. Když se o to pokusíte, vyvolá se .InvalidCastException

IConvertible.ToString(IFormatProvider)

Převede hodnotu této instance na ekvivalentní řetězec pomocí zadané informace o formátování specifické pro jazykovou verzi.

IConvertible.ToType(Type, IFormatProvider)

Popis tohoto člena najdete v tématu ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider)

Popis tohoto člena najdete v tématu ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider)

Popis tohoto člena najdete v tématu ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider)

Popis tohoto člena najdete v tématu ToUInt64(IFormatProvider).

IFormattable.ToString(String, IFormatProvider)

Formátuje hodnotu aktuální instance pomocí zadaného formátu.

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

Pokusí se naformátovat hodnotu aktuální instance do zadaného rozsahu znaků.

Platí pro

Bezpečný přístup z více vláken

Všechny členy tohoto typu jsou zabezpečeny pro přístup z více vláken. Členy, které patrně upravují stav instance, ve skutečnosti vrací novou instanci inicializovanou s použitím nové hodnoty. Jako u jakéhokoli typu, čtení a zápis do sdílené proměnné, která obsahuje instanci tohoto typu, musí být chráněn zámkem, který zaručí bezpečný přístup z více vláken.

Viz také