Char Struktura

Definice

Obor názvů:

System

Sestavení:

System.Runtime.dll

Představuje znak jako jednotku kódu UTF-16.

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

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>

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)

Dědičnost

Object

ValueType

Char

Implementuje

IComparable IComparable<Char> IConvertible IEquatable<Char> IFormattable ISpanFormattable IComparable<TSelf> IEquatable<TSelf> IParsable<Char> IParsable<TSelf> ISpanParsable<Char> ISpanParsable<TSelf> IAdditionOperators<Char,Char,Char> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<Char,Char> IAdditiveIdentity<TSelf,TSelf> IBinaryInteger<Char> IBinaryNumber<Char> IBinaryNumber<TSelf> IBitwiseOperators<Char,Char,Char> IBitwiseOperators<TSelf,TSelf,TSelf> IComparisonOperators<Char,Char,Boolean> IComparisonOperators<TSelf,TSelf,Boolean> IDecrementOperators<Char> IDecrementOperators<TSelf> IDivisionOperators<Char,Char,Char> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<Char,Char,Boolean> IEqualityOperators<TSelf,TOther,TResult> IEqualityOperators<TSelf,TSelf,Boolean> IIncrementOperators<Char> IIncrementOperators<TSelf> IMinMaxValue<Char> IModulusOperators<Char,Char,Char> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<Char,Char> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<Char,Char,Char> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<Char> INumber<TSelf> INumberBase<Char> INumberBase<TSelf> IShiftOperators<Char,Int32,Char> IShiftOperators<TSelf,Int32,TSelf> ISubtractionOperators<Char,Char,Char> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<Char,Char> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<Char,Char> IUnaryPlusOperators<TSelf,TSelf> IUnsignedNumber<Char>

Příklady

Následující příklad kódu ukazuje některé metody 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á Char strukturu k reprezentaci bodů kódu Unicode pomocí kódování UTF-16. Hodnota objektu Char je jeho 16bitová číselná (řadová) hodnota.

Pokud neznáte 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 popisují vztah mezi objektem Char a znakem a popisují některé běžné úlohy prováděné s Char instancemi. Jako alternativu Rune k provádění některých z těchto úloh doporučujeme zvážit Char typ uvedený v .NET Core 3.0.

• Objekty Char, znaky Unicode a řetězce
• Znaky a kategorie znaků
• Znaky a textové prvky
• Běžné operace
• Hodnoty znaků a interoperabilita

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 jednoho znaku 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 kombinujícími znaky. Například znak ä je reprezentován objektem Char , jehož jednotka kódu 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 unicode BMP (Basic Multilingual Plane). Unicode podporuje kromě BMP šestnáct rovin, které představuje rovinu 0. Bod kódu Unicode je v kódování UTF-32 reprezentován 21bitovou hodnotou, která zahrnuje 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ů, znaky mimo BMP jsou reprezentovány náhradními dvojicemi v kódování UTF-16. Následující příklad ukazuje, že UTF-32 ekvivalent U+1D160, hudební symbol OSMÁ POZNÁMKA, je U+D834 U+DD60. U+D834 je vysoký náhradník; Vysoké náhrady jsou v rozsahu od U+D800 až po U+DBFF. U+DD60 je nízká náhrada; Nízké náhrady jsou v rozsahu 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
  

Znaky a kategorie znaků

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

Chcete-li určit kategorii znaku unicode, zavolejte metodu GetUnicodeCategory . Například následující příklad volá metodu , GetUnicodeCategory která zobrazí kategorii 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 metoda závisí 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 od .NET Framework 4 do .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. Například následující příklad převede body kódu Unicode, které představují čísla egejského moře nula až 9, na jednotky kódu kódované UTF-16. Vzhledem k tomu, že objekty chybně přirovnává Char 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:

• Můžete pracovat s objektem v jeho celém rozsahu String , místo abyste pracovali 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 určení počtu textových prvků v řetězci, který se skládá z čísel v Egejském moři nula až devět. Vzhledem k tomu, že považuje náhradní pár 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ězce na jednu jednotku kódu 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 kombinace 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	Pro jeden znak: Convert.ToInt32(Char) Pro 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 je znak v konkrétní kategorii unicode, jako je číslice, písmeno, interpunkce, řídicí znak atd.	IsControl, , IsDigitIsHighSurrogate, , IsLetter, IsLowerIsLetterOrDigit, IsLowSurrogate, IsNumber, IsPunctuation, , IsSeparator, IsSurrogate, IsSurrogatePair, , IsSymbol, IsUpperaIsWhiteSpace Viz také odpovídající metody pro typ Rune .
Převod objektu Char představujícího čí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 interoperabilita

Když se spravovaný Char typ, který je reprezentovaný jako jednotka kódu kódování Unicode UTF-16, předá nespravovanému kódu, zařazovač interop ve výchozím nastavení převede znakovou sadu na ANSI. Atribut můžete použít DllImportAttribute na deklarace vyvolání platformy a StructLayoutAttribute atribut na deklaraci zprostředkovatele komunikace COM, abyste mohli určit, jakou 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 na 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 na stejné pozici v pořadí řazení jako zadaný Objectobjekt .
ConvertFromUtf32(Int32)	Převede zadaný bod kódu Unicode na řetězec kódovaný 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()	Vrátí hodnotu TypeCode pro typ Charhodnoty .
GetUnicodeCategory(Char)	Zařadí zadaný znak Unicode do skupiny identifikované jednou z UnicodeCategory hodnot.
GetUnicodeCategory(String, Int32)	Zařadí znak na zadanou pozici v zadaném řetězci do skupiny identifikované jednou z UnicodeCategory hodnot.
IsAscii(Char)	Vrátí hodnotu true , pokud c je znak ASCII ([ U+0000..U+007F ]).
IsAsciiDigit(Char)	Určuje, zda je znak zařazen do kategorie čí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 kategorie jako šestnáctková číslice ASCII malá písmena.
IsAsciiHexDigitUpper(Char)	Určuje, zda je znak zařazen do kategorie jako hexademická číslice ASCII s velkými písmeny.
IsAsciiLetter(Char)	Určuje, zda je znak zařazen do kategorie jako písmeno ASCII.
IsAsciiLetterLower(Char)	Označuje, zda je znak zařazen do kategorie malé písmeno ASCII.
IsAsciiLetterOrDigit(Char)	Označuje, zda je znak zařazen do kategorie jako písmeno nebo číslice ASCII.
IsAsciiLetterUpper(Char)	Určuje, zda je znak zařazen do kategorie jako velké písmeno ASCII.
IsBetween(Char, Char, Char)	Určuje, zda je znak 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 do kategorie řídicího znaku.
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 desítkové číslice.
IsHighSurrogate(Char)	Určuje, zda je zadaný Char objekt vysokou náhradou.
IsHighSurrogate(String, Int32)	Určuje, zda Char je objekt na zadané pozici v řetězci vysokou náhradou.
IsLetter(Char)	Určuje, zda je zadaný znak unicode zařazen do kategorie jako písmeno unicode.
IsLetter(String, Int32)	Určuje, zda je znak na zadané pozici v zadaném řetězci zařazen do kategorie písmen unicode.
IsLetterOrDigit(Char)	Určuje, zda je zadaný znak unicode zařazen do kategorie 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 kategorie jako malé písmeno.
IsLower(String, Int32)	Určuje, zda je znak na zadané pozici v zadaném řetězci zařazen jako malé písmeno.
IsLowSurrogate(Char)	Určuje, zda je zadaný Char objekt nízkou náhradou.
IsLowSurrogate(String, Int32)	Určuje, zda Char je objekt na zadané pozici v řetězci nízkou náhradou.
IsNumber(Char)	Určuje, zda je zadaný znak unicode zařazen do kategorie čísla.
IsNumber(String, Int32)	Určuje, zda je znak na zadané pozici v zadaném řetězci zařazen do kategorie čísla.
IsPunctuation(Char)	Určuje, zda je zadaný znak unicode zařazen do kategorie 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, jestli je znak na zadané pozici v zadaném řetězci zařazený jako oddělovač znaků.
IsSurrogate(Char)	Určuje, zda má zadaný znak jednotku náhradního kódu.
IsSurrogate(String, Int32)	Určuje, zda znak na zadané pozici v zadaném řetězci má 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í pár.
IsSymbol(Char)	Určuje, zda je zadaný znak unicode zařazen do kategorie jako znak symbolu.
IsSymbol(String, Int32)	Určuje, zda je znak na zadané pozici v zadaném řetězci zařazen jako znak symbolu.
IsUpper(Char)	Určuje, zda je zadaný znak sady Unicode zařazen do kategorie 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 jako prázdné znaky.
Parse(String)	Převede hodnotu zadaného řetězce na jeho ekvivalentní znak Unicode.
ToLower(Char)	Převede hodnotu znaku Unicode na jeho ekvivalent malými písmeny.
ToLower(Char, CultureInfo)	Převede hodnotu zadaného znaku Unicode na jeho ekvivalent malými písmeny pomocí zadaných informací o formátování specifické pro jazykovou verzi.
ToLowerInvariant(Char)	Převede hodnotu znaku Unicode na jeho ekvivalent malými písmeny pomocí pravidel velkých a malý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 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 ekvivalent velkých písmen.
ToUpper(Char, CultureInfo)	Převede hodnotu zadaného znaku Unicode na jeho ekvivalent velkými písmeny pomocí zadaných informací o formátování specifické pro jazykovou verzi.
ToUpperInvariant(Char)	Převede hodnotu znaku Unicode na jeho ekvivalent pro velká písmena pomocí pravidel velikostí písmen 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í

IAdditionOperators<Char,Char,Char>.Addition(Char, Char)	Sečte dvě hodnoty k výpočtu jejich součtu.
IAdditionOperators<Char,Char,Char>.CheckedAddition(Char, Char)	Sečte dvě hodnoty k výpočtu jejich součtu.
IAdditiveIdentity<Char,Char>.AdditiveIdentity	Získá přídatnou identitu aktuálního typu.
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ší dva je doplněk reprezentace aktuální hodnoty.
IBinaryInteger<Char>.LeadingZeroCount(Char)	Vypočítá počet bitů s úvodní nulou v hodnotě.
IBinaryInteger<Char>.PopCount(Char)	Vypočítá počet bitů, které jsou nastaveny v hodnotě.
IBinaryInteger<Char>.RotateLeft(Char, Int32)	Otočí hodnotu, která zbyla o danou částku.
IBinaryInteger<Char>.RotateRight(Char, Int32)	Otočí hodnotu doprava o danou částku.
IBinaryInteger<Char>.TrailingZeroCount(Char)	Vypočítá počet koncových nula bitů v hodnotě.
IBinaryInteger<Char>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Char)	Představuje znak jako jednotku kódu UTF-16.
IBinaryInteger<Char>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Char)	Představuje znak jako jednotku kódu UTF-16.
IBinaryInteger<Char>.TryWriteBigEndian(Span<Byte>, Int32)	Pokusí se zapsat aktuální hodnotu v daném rozsahu ve formátu big-endian.
IBinaryInteger<Char>.TryWriteLittleEndian(Span<Byte>, Int32)	Pokusí se zapsat aktuální hodnotu v daném rozsahu ve formátu little-endian.
IBinaryNumber<Char>.AllBitsSet	Získá instanci binárního typu, ve kterém jsou nastaveny všechny bity.
IBinaryNumber<Char>.IsPow2(Char)	Určuje, zda je hodnota mocnina dva.
IBinaryNumber<Char>.Log2(Char)	Vypočítá log2 hodnoty.
IBitwiseOperators<Char,Char,Char>.BitwiseAnd(Char, Char)	Vypočítá bitové hodnoty a dvou hodnot.
IBitwiseOperators<Char,Char,Char>.BitwiseOr(Char, Char)	Vypočítá bitové nebo dvě hodnoty.
IBitwiseOperators<Char,Char,Char>.ExclusiveOr(Char, Char)	Vypočítá výhradní hodnotu nebo dvou hodnot.
IBitwiseOperators<Char,Char,Char>.OnesComplement(Char)	Vypočítá reprezentaci dané hodnoty jako doplněk.
IComparisonOperators<Char,Char,Boolean>.GreaterThan(Char, Char)	Porovná dvě hodnoty a určí, která je větší.
IComparisonOperators<Char,Char,Boolean>.GreaterThanOrEqual(Char, Char)	Porovná dvě hodnoty a určí, která hodnota je větší nebo rovna.
IComparisonOperators<Char,Char,Boolean>.LessThan(Char, Char)	Porovná dvě hodnoty a určí, která hodnota je menší.
IComparisonOperators<Char,Char,Boolean>.LessThanOrEqual(Char, Char)	Porovná dvě hodnoty a určí, která hodnota je menší nebo rovna.
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.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).
IDecrementOperators<Char>.CheckedDecrement(Char)	Sníží hodnotu.
IDecrementOperators<Char>.Decrement(Char)	Sníží hodnotu.
IDivisionOperators<Char,Char,Char>.Division(Char, Char)	Vydělí jednu hodnotu jinou za účelem výpočtu jejich podílu.
IEqualityOperators<Char,Char,Boolean>.Equality(Char, Char)	Porovná dvě hodnoty a určí rovnost.
IEqualityOperators<Char,Char,Boolean>.Inequality(Char, Char)	Porovná dvě hodnoty a určí nerovnost.
IFormattable.ToString(String, IFormatProvider)	Formátuje hodnotu aktuální instance pomocí zadaného formátu.
IIncrementOperators<Char>.CheckedIncrement(Char)	Zvýší hodnotu.
IIncrementOperators<Char>.Increment(Char)	Zvýší hodnotu.
IMinMaxValue<Char>.MaxValue	Získá maximální hodnotu aktuálního typu.
IMinMaxValue<Char>.MinValue	Získá minimální hodnotu aktuálního typu.
IModulusOperators<Char,Char,Char>.Modulus(Char, Char)	Vydělí dvě hodnoty dohromady za účelem výpočtu jejich modulu nebo zbytku.
IMultiplicativeIdentity<Char,Char>.MultiplicativeIdentity	Získá multiplikativní identitu aktuálního typu.
IMultiplyOperators<Char,Char,Char>.CheckedMultiply(Char, Char)	Vynásobí dvě hodnoty dohromady a vypočítá jejich součin.
IMultiplyOperators<Char,Char,Char>.Multiply(Char, Char)	Vynásobí dvě hodnoty dohromady a vypočítá jejich součin.
INumberBase<Char>.Abs(Char)	Vypočítá absolutní hodnotu.
INumberBase<Char>.IsCanonical(Char)	Určuje, zda je hodnota v kanonické reprezentaci.
INumberBase<Char>.IsComplexNumber(Char)	Určuje, zda hodnota představuje komplexní číslo.
INumberBase<Char>.IsEvenInteger(Char)	Určuje, zda hodnota představuje sudé číslo.
INumberBase<Char>.IsFinite(Char)	Určuje, zda je hodnota konečná.
INumberBase<Char>.IsImaginaryNumber(Char)	Určuje, zda hodnota představuje čisté imaginární číslo.
INumberBase<Char>.IsInfinity(Char)	Určuje, zda je hodnota nekonečná.
INumberBase<Char>.IsInteger(Char)	Určuje, zda hodnota představuje celočíselné číslo.
INumberBase<Char>.IsNaN(Char)	Určuje, jestli je hodnota NaN.
INumberBase<Char>.IsNegative(Char)	Určuje, jestli je hodnota záporná.
INumberBase<Char>.IsNegativeInfinity(Char)	Určuje, zda je hodnota záporné nekonečno.
INumberBase<Char>.IsNormal(Char)	Určuje, zda je hodnota normální.
INumberBase<Char>.IsOddInteger(Char)	Určuje, zda hodnota představuje liché celočíselné číslo.
INumberBase<Char>.IsPositive(Char)	Určuje, jestli je hodnota kladná.
INumberBase<Char>.IsPositiveInfinity(Char)	Určuje, zda je hodnota kladné nekonečno.
INumberBase<Char>.IsRealNumber(Char)	Určuje, zda hodnota představuje reálné číslo.
INumberBase<Char>.IsSubnormal(Char)	Určuje, jestli je hodnota podnormální.
INumberBase<Char>.IsZero(Char)	Určuje, zda je hodnota nula.
INumberBase<Char>.MaxMagnitude(Char, Char)	Porovná dvě hodnoty pro výpočet, který je větší.
INumberBase<Char>.MaxMagnitudeNumber(Char, Char)	Porovná dvě hodnoty pro výpočet, který má větší velikost a vrátí druhou hodnotu, pokud je NaNvstup .
INumberBase<Char>.MinMagnitude(Char, Char)	Porovná dvě hodnoty s výpočtem, který je menší.
INumberBase<Char>.MinMagnitudeNumber(Char, Char)	Porovná dvě hodnoty pro výpočet, který má menší velikost a vrátí druhou hodnotu, pokud je NaNvstup .
INumberBase<Char>.One	Získá hodnotu 1 pro typ.
INumberBase<Char>.Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Parsuje rozsah znaků na hodnotu.
INumberBase<Char>.Parse(String, NumberStyles, IFormatProvider)	Parsuje řetězec na hodnotu.
INumberBase<Char>.Radix	Získá radix nebo základ pro typ.
INumberBase<Char>.TryConvertFromChecked<TOther>(TOther, Char)	Představuje znak jako jednotku kódu UTF-16.
INumberBase<Char>.TryConvertFromSaturating<TOther>(TOther, Char)	Představuje znak jako jednotku kódu UTF-16.
INumberBase<Char>.TryConvertFromTruncating<TOther>(TOther, Char)	Představuje znak jako jednotku kódu UTF-16.
INumberBase<Char>.TryConvertToChecked<TOther>(Char, TOther)	Pokusí se převést instanci aktuálního typu na jiný typ, vyvolá výjimku přetečení pro všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
INumberBase<Char>.TryConvertToSaturating<TOther>(Char, TOther)	Pokusí se převést instanci aktuálního typu na jiný typ, nasytí všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
INumberBase<Char>.TryConvertToTruncating<TOther>(Char, TOther)	Pokusí se převést instanci aktuálního typu na jiný typ a zkrátí všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
INumberBase<Char>.TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Char)	Představuje znak jako jednotku kódu UTF-16.
INumberBase<Char>.TryParse(String, NumberStyles, IFormatProvider, Char)	Představuje znak jako jednotku kódu UTF-16.
INumberBase<Char>.Zero	Získá hodnotu 0 pro typ.
IParsable<Char>.Parse(String, IFormatProvider)	Parsuje řetězec na hodnotu.
IParsable<Char>.TryParse(String, IFormatProvider, Char)	Představuje znak jako jednotku kódu UTF-16.
IShiftOperators<Char,Int32,Char>.LeftShift(Char, Int32)	Posune hodnotu doleva o danou částku.
IShiftOperators<Char,Int32,Char>.RightShift(Char, Int32)	Posune hodnotu doprava o danou částku.
IShiftOperators<Char,Int32,Char>.UnsignedRightShift(Char, Int32)	Posune hodnotu doprava o danou částku.
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Pokusí se naformátovat hodnotu aktuální instance do zadaného rozsahu znaků.
ISpanParsable<Char>.Parse(ReadOnlySpan<Char>, IFormatProvider)	Parsuje rozsah znaků na hodnotu.
ISpanParsable<Char>.TryParse(ReadOnlySpan<Char>, IFormatProvider, Char)	Představuje znak jako jednotku kódu UTF-16.
ISubtractionOperators<Char,Char,Char>.CheckedSubtraction(Char, Char)	Odečte dvě hodnoty pro výpočet jejich rozdílu.
ISubtractionOperators<Char,Char,Char>.Subtraction(Char, Char)	Odečte dvě hodnoty pro výpočet jejich rozdílu.
IUnaryNegationOperators<Char,Char>.CheckedUnaryNegation(Char)	Vypočítá zkontrolované unární negace hodnoty.
IUnaryNegationOperators<Char,Char>.UnaryNegation(Char)	Vypočítá unární negaci hodnoty.
IUnaryPlusOperators<Char,Char>.UnaryPlus(Char)	Vypočítá unární plus hodnoty.

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é

• IComparable
• IConvertible
• String