Char Struktura

Definice

Obor názvů:

System

Sestavení:

System.Runtime.dll

Source:

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 najdete v tématu Doplňkové poznámky k rozhraní API pro Char.

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.
IUtf8SpanFormattable.TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Pokusí se naformátovat hodnotu aktuální instance jako UTF-8 do zadaného rozsahu bajtů.

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