Char Struktura

Definice

Obor názvů:

System

Sestavení:

System.Runtime.dll

Zdroj:

Char.cs

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

public value class char : IComparable<char>, IConvertible, IEquatable<char>, IParsable<char>, ISpanParsable<char>, IUtf8SpanParsable<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>, IUtf8SpanParsable<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 IUtf8SpanFormattable
    interface IUtf8SpanParsable<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), IUtf8SpanParsable(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> IUtf8SpanFormattable IUtf8SpanParsable<Char> IUtf8SpanParsable<TSelf>

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

Další informace o tomto rozhraní API naleznete v tématu Doplňkové poznámky k rozhraní API pro Char.

Pole

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

Metody

CompareTo(Char)	Porovná tuto instanci se zadaným objektem Char a určuje, zda tato instance předchází, následuje nebo se zobrazí ve stejném pořadí řazení jako zadaný objekt Char.
CompareTo(Object)	Porovná tuto instanci se zadaným objektem a určuje, zda tato instance předchází, následuje nebo se zobrazí ve stejném pořadí řazení jako zadaná Object.
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ího páru 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 znakový bod Unicode.
Equals(Char)	Vrátí hodnotu, která určuje, zda je tato instance rovna zadanému Char objektu.
Equals(Object)	Vrátí hodnotu, která určuje, zda je tato instance rovna zadanému objektu.
GetHashCode()	Vrátí kód hash pro tuto instanci.
GetNumericValue(Char)	Převede zadaný číselný znak Unicode na číslo s plovoucí desetinnou čárkou s dvojitou přesností.
GetNumericValue(String, Int32)	Převede číselný znak Unicode na určené pozici v zadaném řetězci na číslo s plovoucí desetinnou čárkou s dvojitou přesností.
GetTypeCode()	Vrátí TypeCode pro typ hodnoty Char.
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 hodnot UnicodeCategory.
IsAscii(Char)	Vrátí true, pokud je c znak ASCII ([ U+0000..U+007F ]).
IsAsciiDigit(Char)	Určuje, zda je znak zařazen do kategorie jako číslice ASCII.
IsAsciiHexDigit(Char)	Určuje, zda je znak zařazen do kategorie jako šestnáctková číslice ASCII.
IsAsciiHexDigitLower(Char)	Určuje, zda je znak zařazen do kategorií jako šestnáctková číslice ASCII s menším písmenem.
IsAsciiHexDigitUpper(Char)	Určuje, zda je znak zařazen do kategorií jako šestnáctková číslice ASCII s velkými písmeny.
IsAsciiLetter(Char)	Označuje, zda je znak zařazen do kategorie jako písmeno ASCII.
IsAsciiLetterLower(Char)	Označuje, zda je znak zařazen do kategorií jako malá písmena ASCII.
IsAsciiLetterOrDigit(Char)	Určuje, zda je znak zařazen do kategorií jako písmeno ASCII nebo číslice.
IsAsciiLetterUpper(Char)	Určuje, zda je znak zařazen do kategorií jako velké písmeno ASCII.
IsBetween(Char, Char, Char)	Určuje, zda je znak v zadaném inkluzivním rozsahu.
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 jako řídicí znak.
IsDigit(Char)	Určuje, zda je zadaný znak Unicode zařazen do kategorií jako desetinná číslice.
IsDigit(String, Int32)	Určuje, zda je znak na zadané pozici v zadaném řetězci zařazený do kategorií jako desetinná číslice.
IsHighSurrogate(Char)	Určuje, zda zadaný Char objektu je vysoká náhrada.
IsHighSurrogate(String, Int32)	Určuje, zda Char objekt na zadané pozici v řetězci je vysoká náhrada.
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 kategorií jako písmeno nebo desetinná číslice.
IsLower(Char)	Určuje, zda je zadaný znak Unicode zařazen do kategorií jako malá písmena.
IsLower(String, Int32)	Určuje, zda je znak na zadané pozici v zadaném řetězci zařazen do kategorií jako malá písmena.
IsLowSurrogate(Char)	Určuje, zda zadaný Char objekt je nízká náhrada.
IsLowSurrogate(String, Int32)	Určuje, zda Char objektu na zadané pozici v řetězci je nízká náhrada.
IsNumber(Char)	Určuje, zda je zadaný znak Unicode zařazen do kategorie jako číslo.
IsNumber(String, Int32)	Určuje, zda je znak na zadané pozici v zadaném řetězci zařazený do kategorie jako číslo.
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ý do kategorií jako interpunkční znaménko.
IsSeparator(Char)	Určuje, jestli je zadaný znak Unicode zařazený do kategorie jako oddělovač.
IsSeparator(String, Int32)	Určuje, zda je znak na zadané pozici v zadaném řetězci zařazen do kategorie jako oddělovač.
IsSurrogate(Char)	Určuje, zda zadaný znak má náhradní jednotku 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í dvojici.
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 Unicode zařazen do kategorií jako velká písmena.
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 kategorií jako prázdné znaky.
IsWhiteSpace(String, Int32)	Určuje, zda je znak na zadané pozici v zadaném řetězci zařazen do kategorií jako prázdné znaky.
Parse(String)	Převede hodnotu zadaného řetězce na 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 malá písmena ekvivalent pomocí zadaných informací o formátování specifické pro jazykovou verzi.
ToLowerInvariant(Char)	Převede hodnotu znaku Unicode na jeho malá písmena pomocí pravidel velikostí písmen invariantní jazykové verze.
ToString()	Převede hodnotu této instance na ekvivalentní řetězcové vyjádření.
ToString(Char)	Převede zadaný znak Unicode na jeho ekvivalentní řetězcové vyjádření.
ToString(IFormatProvider)	Převede hodnotu této instance na ekvivalentní řetězcové vyjádření pomocí zadaných informací o formátu specifickém pro jazykovou verzi.
ToUpper(Char)	Převede hodnotu znaku Unicode na jeho velká písmena ekvivalent.
ToUpper(Char, CultureInfo)	Převede hodnotu zadaného znaku Unicode na jeho velká písmena ekvivalent pomocí zadaných informací o formátování specifické pro jazykovou verzi.
ToUpperInvariant(Char)	Převede hodnotu znaku Unicode na jeho velká písmena ekvivalent pomocí pravidel velikostí písmen invariantní jazykové verze.
TryParse(String, Char)	Převede hodnotu zadaného řetězce na 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 ke výpočtu jejich součtu.
IAdditionOperators<Char,Char,Char>.CheckedAddition(Char, Char)	Sečte dvě hodnoty ke 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šího dvou doplňku reprezentace aktuální hodnoty.
IBinaryInteger<Char>.LeadingZeroCount(Char)	Vypočítá počet úvodních nul bitů v hodnotě.
IBinaryInteger<Char>.PopCount(Char)	Vypočítá počet bitů, které jsou nastavené v hodnotě.
IBinaryInteger<Char>.RotateLeft(Char, Int32)	Otočí hodnotu doleva o danou částku.
IBinaryInteger<Char>.RotateRight(Char, Int32)	Otočí hodnotu doprava o danou částku.
IBinaryInteger<Char>.TrailingZeroCount(Char)	Vypočítá počet koncových bitů nuly 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 na daný rozsah napsat aktuální hodnotu ve formátu big-endian.
IBinaryInteger<Char>.TryWriteLittleEndian(Span<Byte>, Int32)	Pokusí se na daný rozsah napsat aktuální hodnotu v malém endian formátu.
IBinaryNumber<Char>.AllBitsSet	Získá instanci binárního typu, ve které jsou nastaveny všechny bity.
IBinaryNumber<Char>.IsPow2(Char)	Určuje, zda je hodnota mocnina dvou.
IBinaryNumber<Char>.Log2(Char)	Vypočítá protokol 2 hodnoty.
IBitwiseOperators<Char,Char,Char>.BitwiseAnd(Char, Char)	Vypočítá bitové a dvě hodnoty.
IBitwiseOperators<Char,Char,Char>.BitwiseOr(Char, Char)	Vypočítá bitové nebo dvě hodnoty.
IBitwiseOperators<Char,Char,Char>.ExclusiveOr(Char, Char)	Vypočítá výhradní nebo dvě hodnoty.
IBitwiseOperators<Char,Char,Char>.OnesComplement(Char)	Vypočítá reprezentaci daného doplňku.
IComparisonOperators<Char,Char,Boolean>.GreaterThan(Char, Char)	Porovná dvě hodnoty a určí, která hodnota 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. Pokus o to vyvolá 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. Pokus o to vyvolá InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	Poznámka Tento převod není podporován. Pokus o to vyvolá InvalidCastException.
IConvertible.ToDouble(IFormatProvider)	Poznámka Tento převod není podporován. Pokus o to vyvolá 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. Pokus o to vyvolá 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)	Dekrementuje hodnotu.
IDecrementOperators<Char>.Decrement(Char)	Dekrementuje hodnotu.
IDivisionOperators<Char,Char,Char>.Division(Char, Char)	Vydělí jednu hodnotu jinou, aby se vypočítá jejich podíl.
IEqualityOperators<Char,Char,Boolean>.Equality(Char, Char)	Porovná dvě hodnoty k určení rovnosti.
IEqualityOperators<Char,Char,Boolean>.Inequality(Char, Char)	Porovná dvě hodnoty k určení nerovnosti.
IFormattable.ToString(String, IFormatProvider)	Naformá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)	Rozdělí dvě hodnoty dohromady a vypočítá jejich moduly nebo zbytek.
IMultiplicativeIdentity<Char,Char>.MultiplicativeIdentity	Získá multiplikativní identitu aktuálního typu.
IMultiplyOperators<Char,Char,Char>.CheckedMultiply(Char, Char)	Vynásobí dvě hodnoty dohromady pro výpočet jejich produktu.
IMultiplyOperators<Char,Char,Char>.Multiply(Char, Char)	Vynásobí dvě hodnoty dohromady pro výpočet jejich produktu.
INumberBase<Char>.Abs(Char)	Vypočítá absolutní hodnotu.
INumberBase<Char>.IsCanonical(Char)	Určuje, zda je hodnota v kanonickém vyjádření.
INumberBase<Char>.IsComplexNumber(Char)	Určuje, zda hodnota představuje komplexní číslo.
INumberBase<Char>.IsEvenInteger(Char)	Určuje, zda hodnota představuje sudé celočíselné číslo.
INumberBase<Char>.IsFinite(Char)	Určuje, zda je hodnota konečná.
INumberBase<Char>.IsImaginaryNumber(Char)	Určuje, jestli 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, zda 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, jestli 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, jestli je hodnota nula.
INumberBase<Char>.MaxMagnitude(Char, Char)	Porovná dvě hodnoty s výpočty, které jsou větší.
INumberBase<Char>.MaxMagnitudeNumber(Char, Char)	Porovná dvě hodnoty k výpočtu, které mají větší velikost a vrátí druhou hodnotu, pokud je vstup NaN.
INumberBase<Char>.MinMagnitude(Char, Char)	Porovná dvě hodnoty s výpočetními prostředky, které jsou menší.
INumberBase<Char>.MinMagnitudeNumber(Char, Char)	Porovná dvě hodnoty k výpočtu, které mají menší velikost a vrátí druhou hodnotu, pokud je vstup NaN.
INumberBase<Char>.One	Získá hodnotu 1 pro typ.
INumberBase<Char>.Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Parsuje rozsah znaků do hodnoty.
INumberBase<Char>.Parse(String, NumberStyles, IFormatProvider)	Parsuje řetězec do hodnoty.
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 a 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 a 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 do hodnoty.
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ů do hodnoty.
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á zaškrtnutou unární negaci hodnoty.
IUnaryNegationOperators<Char,Char>.UnaryNegation(Char)	Vypočítá unární negaci hodnoty.
IUnaryPlusOperators<Char,Char>.UnaryPlus(Char)	Vypočítá unární plus hodnoty.
IUtf8SpanFormattable.TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Pokusí se naformátovat hodnotu aktuální instance jako UTF-8 do poskytnutého rozsahu bajtů.

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

Všichni členové tohoto typu jsou bezpečné pro přístup z více vláken. Členové, kteří se zdá, že upravují stav instance, ve skutečnosti vrátí novou instanci inicializovanou s novou hodnotou. Stejně jako u jakéhokoli jiného typu musí být čtení a zápis do sdílené proměnné, která obsahuje instanci tohoto typu, chráněn zámkem, aby se zajistilo zabezpečení vlákna.

Viz také

• IComparable
• IConvertible
• String