Char Struktura

Definicja

Przestrzeń nazw:

System

Zestaw:

System.Runtime.dll

Źródło:

Char.cs

Reprezentuje znak jako jednostkę kodu 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)

Dziedziczenie

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>

Przykłady

Poniższy przykład kodu przedstawia niektóre metody w Char.

using namespace System;
int main()
{
   char chA = 'A';
   char ch1 = '1';
   String^ str =  "test string";
   Console::WriteLine( chA.CompareTo( 'B' ) ); // Output: "-1" (meaning 'A' is 1 less than 'B')
   Console::WriteLine( chA.Equals( 'A' ) ); // Output: "True"
   Console::WriteLine( Char::GetNumericValue( ch1 ) ); // Output: "1"
   Console::WriteLine( Char::IsControl( '\t' ) ); // Output: "True"
   Console::WriteLine( Char::IsDigit( ch1 ) ); // Output: "True"
   Console::WriteLine( Char::IsLetter( ',' ) ); // Output: "False"
   Console::WriteLine( Char::IsLower( 'u' ) ); // Output: "True"
   Console::WriteLine( Char::IsNumber( ch1 ) ); // Output: "True"
   Console::WriteLine( Char::IsPunctuation( '.' ) ); // Output: "True"
   Console::WriteLine( Char::IsSeparator( str, 4 ) ); // Output: "True"
   Console::WriteLine( Char::IsSymbol( '+' ) ); // Output: "True"
   Console::WriteLine( Char::IsWhiteSpace( str, 4 ) ); // Output: "True"
   Console::WriteLine( Char::Parse(  "S" ) ); // Output: "S"
   Console::WriteLine( Char::ToLower( 'M' ) ); // Output: "m"
   Console::WriteLine( 'x' ); // Output: "x"
}

using System;

public class CharStructureSample
{
    public static void Main()
    {
        char chA = 'A';
        char ch1 = '1';
        string str = "test string";

        Console.WriteLine(chA.CompareTo('B'));          //-----------  Output: "-1" (meaning 'A' is 1 less than 'B')
        Console.WriteLine(chA.Equals('A'));             //-----------  Output: "True"
        Console.WriteLine(Char.GetNumericValue(ch1));   //-----------  Output: "1"
        Console.WriteLine(Char.IsControl('\t'));        //-----------  Output: "True"
        Console.WriteLine(Char.IsDigit(ch1));           //-----------  Output: "True"
        Console.WriteLine(Char.IsLetter(','));          //-----------  Output: "False"
        Console.WriteLine(Char.IsLower('u'));           //-----------  Output: "True"
        Console.WriteLine(Char.IsNumber(ch1));          //-----------  Output: "True"
        Console.WriteLine(Char.IsPunctuation('.'));     //-----------  Output: "True"
        Console.WriteLine(Char.IsSeparator(str, 4));    //-----------  Output: "True"
        Console.WriteLine(Char.IsSymbol('+'));          //-----------  Output: "True"
        Console.WriteLine(Char.IsWhiteSpace(str, 4));   //-----------  Output: "True"
        Console.WriteLine(Char.Parse("S"));             //-----------  Output: "S"
        Console.WriteLine(Char.ToLower('M'));           //-----------  Output: "m"
        Console.WriteLine('x'.ToString());              //-----------  Output: "x"
    }
}

open System

let chA = 'A'
let ch1 = '1'
let str = "test string"

printfn $"{chA.CompareTo 'B'}"          //-----------  Output: "-1" (meaning 'A' is 1 less than 'B')
printfn $"{chA.Equals 'A'}"             //-----------  Output: "True"
printfn $"{Char.GetNumericValue ch1}"   //-----------  Output: "1"
printfn $"{Char.IsControl '\t'}"        //-----------  Output: "True"
printfn $"{Char.IsDigit ch1}"           //-----------  Output: "True"
printfn $"{Char.IsLetter ','}"          //-----------  Output: "False"
printfn $"{Char.IsLower 'u'}"           //-----------  Output: "True"
printfn $"{Char.IsNumber ch1}"          //-----------  Output: "True"
printfn $"{Char.IsPunctuation '.'}"     //-----------  Output: "True"
printfn $"{Char.IsSeparator(str, 4)}"   //-----------  Output: "True"
printfn $"{Char.IsSymbol '+'}"          //-----------  Output: "True"
printfn $"{Char.IsWhiteSpace(str, 4)}"  //-----------  Output: "True"
printfn $"""{Char.Parse "S"}"""         //-----------  Output: "S"
printfn $"{Char.ToLower 'M'}"           //-----------  Output: "m"
printfn $"{'x'}"                        //-----------  Output: "x"

Module CharStructure

    Public Sub Main()

        Dim chA As Char
        chA = "A"c
        Dim ch1 As Char
        ch1 = "1"c
        Dim str As String
        str = "test string"

        Console.WriteLine(chA.CompareTo("B"c))          ' Output: "-1" (meaning 'A' is 1 less than 'B')
        Console.WriteLine(chA.Equals("A"c))             ' Output: "True"
        Console.WriteLine(Char.GetNumericValue(ch1))    ' Output: "1"
        Console.WriteLine(Char.IsControl(Chr(9)))       ' Output: "True"
        Console.WriteLine(Char.IsDigit(ch1))            ' Output: "True"
        Console.WriteLine(Char.IsLetter(","c))          ' Output: "False"
        Console.WriteLine(Char.IsLower("u"c))           ' Output: "True"
        Console.WriteLine(Char.IsNumber(ch1))           ' Output: "True"
        Console.WriteLine(Char.IsPunctuation("."c))     ' Output: "True"
        Console.WriteLine(Char.IsSeparator(str, 4))     ' Output: "True"
        Console.WriteLine(Char.IsSymbol("+"c))          ' Output: "True"
        Console.WriteLine(Char.IsWhiteSpace(str, 4))    ' Output: "True"
        Console.WriteLine(Char.Parse("S"))              ' Output: "S"
        Console.WriteLine(Char.ToLower("M"c))           ' Output: "m"
        Console.WriteLine("x"c.ToString())              ' Output: "x"

    End Sub

End Module

Uwagi

Aby uzyskać więcej informacji na temat tego interfejsu API, zobacz uwagi dotyczące dodatkowego interfejsu API char.

Pola

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

Metody

CompareTo(Char)	Porównuje to wystąpienie z określonym obiektem Char i wskazuje, czy to wystąpienie poprzedza, następuje lub pojawia się w tej samej kolejności sortowania co określony obiekt Char.
CompareTo(Object)	Porównuje to wystąpienie z określonym obiektem i wskazuje, czy to wystąpienie poprzedza, następuje lub pojawia się w tej samej kolejności sortowania co określony Object.
ConvertFromUtf32(Int32)	Konwertuje określony punkt kodu Unicode na ciąg zakodowany w formacie UTF-16.
ConvertToUtf32(Char, Char)	Konwertuje wartość zakodowanej pary zastępczej UTF-16 na punkt kodu Unicode.
ConvertToUtf32(String, Int32)	Konwertuje wartość zakodowanego znaku UTF-16 lub pary zastępczej na określonej pozycji w ciągu na punkt kodu Unicode.
Equals(Char)	Zwraca wartość wskazującą, czy to wystąpienie jest równe określonemu obiektowi Char.
Equals(Object)	Zwraca wartość wskazującą, czy to wystąpienie jest równe określonemu obiektowi.
GetHashCode()	Zwraca kod skrótu dla tego wystąpienia.
GetNumericValue(Char)	Konwertuje określony znak Unicode liczbowy na liczbę zmiennoprzecinkową o podwójnej precyzji.
GetNumericValue(String, Int32)	Konwertuje numeryczny znak Unicode na określoną pozycję w określonym ciągu na liczbę zmiennoprzecinkową o podwójnej precyzji.
GetTypeCode()	Zwraca TypeCode dla typu wartości Char.
GetUnicodeCategory(Char)	Kategoryzuje określony znak Unicode w grupie identyfikowanej przez jedną z wartości UnicodeCategory.
GetUnicodeCategory(String, Int32)	Kategoryzuje znak na określonej pozycji w określonym ciągu w grupie zidentyfikowanej przez jedną z wartości UnicodeCategory.
IsAscii(Char)	Zwraca true, jeśli c jest znakiem ASCII ([ U+0000.U+007F ]).
IsAsciiDigit(Char)	Wskazuje, czy znak jest klasyfikowany jako cyfra ASCII.
IsAsciiHexDigit(Char)	Wskazuje, czy znak jest klasyfikowany jako cyfra szesnastkowy ASCII.
IsAsciiHexDigitLower(Char)	Wskazuje, czy znak jest klasyfikowany jako cyfra szesnastkowy ASCII.
IsAsciiHexDigitUpper(Char)	Wskazuje, czy znak jest klasyfikowany jako cyfra szesnastkowy ASCII.
IsAsciiLetter(Char)	Wskazuje, czy znak jest klasyfikowany jako litera ASCII.
IsAsciiLetterLower(Char)	Wskazuje, czy znak jest klasyfikowany jako mała litera ASCII.
IsAsciiLetterOrDigit(Char)	Wskazuje, czy znak jest klasyfikowany jako litera ASCII lub cyfra.
IsAsciiLetterUpper(Char)	Wskazuje, czy znak jest klasyfikowany jako wielka litera ASCII.
IsBetween(Char, Char, Char)	Wskazuje, czy znak znajduje się w określonym zakresie inkluzywnym.
IsControl(Char)	Wskazuje, czy określony znak Unicode jest klasyfikowany jako znak kontrolny.
IsControl(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest klasyfikowany jako znak kontrolny.
IsDigit(Char)	Wskazuje, czy określony znak Unicode jest klasyfikowany jako cyfra dziesiętna.
IsDigit(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest klasyfikowany jako cyfra dziesiętna.
IsHighSurrogate(Char)	Wskazuje, czy określony obiekt Char jest wysokim surogatem.
IsHighSurrogate(String, Int32)	Wskazuje, czy obiekt Char na określonej pozycji w ciągu jest wysokim zastępcą.
IsLetter(Char)	Wskazuje, czy określony znak Unicode jest klasyfikowany jako litera Unicode.
IsLetter(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest klasyfikowany jako litera Unicode.
IsLetterOrDigit(Char)	Wskazuje, czy określony znak Unicode jest klasyfikowany jako litera, czy cyfra dziesiętna.
IsLetterOrDigit(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest klasyfikowany jako litera lub cyfra dziesiętna.
IsLower(Char)	Wskazuje, czy określony znak Unicode jest klasyfikowany jako mała litera.
IsLower(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest klasyfikowany jako mała litera.
IsLowSurrogate(Char)	Wskazuje, czy określony obiekt Char jest niskim surogatem.
IsLowSurrogate(String, Int32)	Wskazuje, czy obiekt Char na określonej pozycji w ciągu jest niskim zastępcą.
IsNumber(Char)	Wskazuje, czy określony znak Unicode jest klasyfikowany jako liczba.
IsNumber(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest klasyfikowany jako liczba.
IsPunctuation(Char)	Wskazuje, czy określony znak Unicode jest klasyfikowany jako znak interpunkcyjny.
IsPunctuation(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest klasyfikowany jako znak interpunkcyjny.
IsSeparator(Char)	Wskazuje, czy określony znak Unicode jest klasyfikowany jako znak separatora.
IsSeparator(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest klasyfikowany jako znak separatora.
IsSurrogate(Char)	Wskazuje, czy określony znak ma zastępczą jednostkę kodu.
IsSurrogate(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu ma zastępczą jednostkę kodu.
IsSurrogatePair(Char, Char)	Wskazuje, czy dwa określone obiekty Char tworzą parę zastępczą.
IsSurrogatePair(String, Int32)	Wskazuje, czy dwa sąsiadujące obiekty Char na określonej pozycji w ciągu tworzą parę zastępczą.
IsSymbol(Char)	Wskazuje, czy określony znak Unicode jest klasyfikowany jako znak symbolu.
IsSymbol(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest klasyfikowany jako znak symbolu.
IsUpper(Char)	Wskazuje, czy określony znak Unicode jest klasyfikowany jako wielka litera.
IsUpper(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest klasyfikowany jako wielka litera.
IsWhiteSpace(Char)	Wskazuje, czy określony znak Unicode jest skategoryzowany jako biały znak.
IsWhiteSpace(String, Int32)	Wskazuje, czy znak na określonej pozycji w określonym ciągu jest klasyfikowany jako biały znak.
Parse(String)	Konwertuje wartość określonego ciągu na odpowiedni znak Unicode.
ToLower(Char)	Konwertuje wartość znaku Unicode na jego małe litery równoważne.
ToLower(Char, CultureInfo)	Konwertuje wartość określonego znaku Unicode na jego małe litery równoważne przy użyciu określonych informacji formatowania specyficznych dla kultury.
ToLowerInvariant(Char)	Konwertuje wartość znaku Unicode na jej małe litery równoważne przy użyciu reguł wielkości liter niezmiennej kultury.
ToString()	Konwertuje wartość tego wystąpienia na równoważną reprezentację ciągu.
ToString(Char)	Konwertuje określony znak Unicode na równoważną reprezentację ciągu.
ToString(IFormatProvider)	Konwertuje wartość tego wystąpienia na równoważną reprezentację ciągu przy użyciu określonych informacji o formacie specyficznym dla kultury.
ToUpper(Char)	Konwertuje wartość znaku Unicode na jego wielkie litery równoważne.
ToUpper(Char, CultureInfo)	Konwertuje wartość określonego znaku Unicode na jego wielkie litery równoważne przy użyciu określonych informacji o formatowaniu specyficznym dla kultury.
ToUpperInvariant(Char)	Konwertuje wartość znaku Unicode na jego wielkie litery równoważne przy użyciu reguł wielkości liter niezmiennej kultury.
TryParse(String, Char)	Konwertuje wartość określonego ciągu na odpowiedni znak Unicode. Kod powrotny wskazuje, czy konwersja zakończyła się powodzeniem, czy niepowodzeniem.

Jawne implementacje interfejsu

IAdditionOperators<Char,Char,Char>.Addition(Char, Char)	Dodaje dwie wartości w celu obliczenia ich sumy.
IAdditionOperators<Char,Char,Char>.CheckedAddition(Char, Char)	Dodaje dwie wartości w celu obliczenia ich sumy.
IAdditiveIdentity<Char,Char>.AdditiveIdentity	Pobiera tożsamość addytywnego bieżącego typu.
IBinaryInteger<Char>.GetByteCount()	Pobiera liczbę bajtów, które zostaną zapisane w ramach TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<Char>.GetShortestBitLength()	Pobiera długość w bitach najkrótszej reprezentacji wartości bieżącej.
IBinaryInteger<Char>.LeadingZeroCount(Char)	Oblicza liczbę bitów zera wiodącego w wartości.
IBinaryInteger<Char>.PopCount(Char)	Oblicza liczbę bitów ustawionych w wartości.
IBinaryInteger<Char>.RotateLeft(Char, Int32)	Obraca wartość pozostawioną przez daną kwotę.
IBinaryInteger<Char>.RotateRight(Char, Int32)	Obraca wartość w prawo o daną kwotę.
IBinaryInteger<Char>.TrailingZeroCount(Char)	Oblicza liczbę bitów końcowych zero w wartości.
IBinaryInteger<Char>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Char)	Reprezentuje znak jako jednostkę kodu UTF-16.
IBinaryInteger<Char>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Char)	Reprezentuje znak jako jednostkę kodu UTF-16.
IBinaryInteger<Char>.TryWriteBigEndian(Span<Byte>, Int32)	Próbuje zapisać bieżącą wartość w formacie big-endian do danego zakresu.
IBinaryInteger<Char>.TryWriteLittleEndian(Span<Byte>, Int32)	Próbuje zapisać bieżącą wartość w formacie little-endian do danego zakresu.
IBinaryNumber<Char>.AllBitsSet	Pobiera wystąpienie typu binarnego, w którym są ustawione wszystkie bity.
IBinaryNumber<Char>.IsPow2(Char)	Określa, czy wartość jest potęgą dwóch.
IBinaryNumber<Char>.Log2(Char)	Oblicza dziennik2 wartości.
IBitwiseOperators<Char,Char,Char>.BitwiseAnd(Char, Char)	Oblicza bitowe wartości i dwie wartości.
IBitwiseOperators<Char,Char,Char>.BitwiseOr(Char, Char)	Oblicza bitowe lub dwie wartości.
IBitwiseOperators<Char,Char,Char>.ExclusiveOr(Char, Char)	Oblicza wyłącznie lub dwie wartości.
IBitwiseOperators<Char,Char,Char>.OnesComplement(Char)	Oblicza reprezentację danej wartości jako uzupełnienie.
IComparisonOperators<Char,Char,Boolean>.GreaterThan(Char, Char)	Porównuje dwie wartości, aby określić, która wartość jest większa.
IComparisonOperators<Char,Char,Boolean>.GreaterThanOrEqual(Char, Char)	Porównuje dwie wartości, aby określić, które wartości są większe lub równe.
IComparisonOperators<Char,Char,Boolean>.LessThan(Char, Char)	Porównuje dwie wartości, aby określić, które wartości są mniejsze.
IComparisonOperators<Char,Char,Boolean>.LessThanOrEqual(Char, Char)	Porównuje dwie wartości, aby określić, które wartości są mniejsze lub równe.
IConvertible.ToBoolean(IFormatProvider)	Uwaga Ta konwersja nie jest obsługiwana. Próba wykonania tej czynności zgłasza InvalidCastException.
IConvertible.ToByte(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToChar(IFormatProvider).
IConvertible.ToDateTime(IFormatProvider)	Uwaga Ta konwersja nie jest obsługiwana. Próba wykonania tej czynności zgłasza InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	Uwaga Ta konwersja nie jest obsługiwana. Próba wykonania tej czynności zgłasza InvalidCastException.
IConvertible.ToDouble(IFormatProvider)	Uwaga Ta konwersja nie jest obsługiwana. Próba wykonania tej czynności zgłasza InvalidCastException.
IConvertible.ToInt16(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Uwaga Ta konwersja nie jest obsługiwana. Próba wykonania tej czynności zgłasza InvalidCastException.
IConvertible.ToType(Type, IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToUInt64(IFormatProvider).
IDecrementOperators<Char>.CheckedDecrement(Char)	Dekrementuje wartość.
IDecrementOperators<Char>.Decrement(Char)	Dekrementuje wartość.
IDivisionOperators<Char,Char,Char>.Division(Char, Char)	Dzieli jedną wartość przez inną, aby obliczyć ich iloraz.
IEqualityOperators<Char,Char,Boolean>.Equality(Char, Char)	Porównuje dwie wartości w celu określenia równości.
IEqualityOperators<Char,Char,Boolean>.Inequality(Char, Char)	Porównuje dwie wartości w celu określenia nierówności.
IFormattable.ToString(String, IFormatProvider)	Formatuje wartość bieżącego wystąpienia przy użyciu określonego formatu.
IIncrementOperators<Char>.CheckedIncrement(Char)	Zwiększa wartość.
IIncrementOperators<Char>.Increment(Char)	Zwiększa wartość.
IMinMaxValue<Char>.MaxValue	Pobiera maksymalną wartość bieżącego typu.
IMinMaxValue<Char>.MinValue	Pobiera minimalną wartość bieżącego typu.
IModulusOperators<Char,Char,Char>.Modulus(Char, Char)	Dzieli dwie wartości, aby obliczyć ich modulo lub resztę.
IMultiplicativeIdentity<Char,Char>.MultiplicativeIdentity	Pobiera mnożenie tożsamości bieżącego typu.
IMultiplyOperators<Char,Char,Char>.CheckedMultiply(Char, Char)	Mnoży dwie wartości, aby obliczyć swój produkt.
IMultiplyOperators<Char,Char,Char>.Multiply(Char, Char)	Mnoży dwie wartości, aby obliczyć swój produkt.
INumberBase<Char>.Abs(Char)	Oblicza wartość bezwzględną.
INumberBase<Char>.IsCanonical(Char)	Określa, czy wartość znajduje się w jej kanonicznej reprezentacji.
INumberBase<Char>.IsComplexNumber(Char)	Określa, czy wartość reprezentuje liczbę zespolonej.
INumberBase<Char>.IsEvenInteger(Char)	Określa, czy wartość reprezentuje liczbę całkowitą parzystą.
INumberBase<Char>.IsFinite(Char)	Określa, czy wartość jest skończona.
INumberBase<Char>.IsImaginaryNumber(Char)	Określa, czy wartość reprezentuje czystą liczbę wyimaginowaną.
INumberBase<Char>.IsInfinity(Char)	Określa, czy wartość jest nieskończona.
INumberBase<Char>.IsInteger(Char)	Określa, czy wartość reprezentuje liczbę całkowitą.
INumberBase<Char>.IsNaN(Char)	Określa, czy wartość to NaN.
INumberBase<Char>.IsNegative(Char)	Określa, czy wartość jest ujemna.
INumberBase<Char>.IsNegativeInfinity(Char)	Określa, czy wartość jest ujemną nieskończonością.
INumberBase<Char>.IsNormal(Char)	Określa, czy wartość jest normalna.
INumberBase<Char>.IsOddInteger(Char)	Określa, czy wartość reprezentuje nieparzystną liczbę całkowitą.
INumberBase<Char>.IsPositive(Char)	Określa, czy wartość jest dodatnia.
INumberBase<Char>.IsPositiveInfinity(Char)	Określa, czy wartość jest dodatnią nieskończonością.
INumberBase<Char>.IsRealNumber(Char)	Określa, czy wartość reprezentuje liczbę rzeczywistą.
INumberBase<Char>.IsSubnormal(Char)	Określa, czy wartość jest nienormalna.
INumberBase<Char>.IsZero(Char)	Określa, czy wartość ma wartość zero.
INumberBase<Char>.MaxMagnitude(Char, Char)	Porównuje dwie wartości z obliczeniami, które są większe.
INumberBase<Char>.MaxMagnitudeNumber(Char, Char)	Porównuje dwie wartości z obliczeniami o większej wielkości i zwraca drugą wartość, jeśli dane wejściowe są NaN.
INumberBase<Char>.MinMagnitude(Char, Char)	Porównuje dwie wartości z obliczeniami, które są mniejsze.
INumberBase<Char>.MinMagnitudeNumber(Char, Char)	Porównuje dwie wartości z obliczeniami o mniejszej wielkości i zwraca drugą wartość, jeśli dane wejściowe są NaN.
INumberBase<Char>.One	Pobiera wartość 1 dla typu.
INumberBase<Char>.Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Analizuje zakres znaków w wartości.
INumberBase<Char>.Parse(String, NumberStyles, IFormatProvider)	Analizuje ciąg w wartości.
INumberBase<Char>.Radix	Pobiera promienie lub podstawę dla typu.
INumberBase<Char>.TryConvertFromChecked<TOther>(TOther, Char)	Reprezentuje znak jako jednostkę kodu UTF-16.
INumberBase<Char>.TryConvertFromSaturating<TOther>(TOther, Char)	Reprezentuje znak jako jednostkę kodu UTF-16.
INumberBase<Char>.TryConvertFromTruncating<TOther>(TOther, Char)	Reprezentuje znak jako jednostkę kodu UTF-16.
INumberBase<Char>.TryConvertToChecked<TOther>(Char, TOther)	Próbuje przekonwertować wystąpienie bieżącego typu na inny typ, zgłaszając wyjątek przepełnienia dla wszystkich wartości, które mieszczą się poza dopuszczalnym zakresem bieżącego typu.
INumberBase<Char>.TryConvertToSaturating<TOther>(Char, TOther)	Próbuje przekonwertować wystąpienie bieżącego typu na inny typ, saturując wszystkie wartości, które mieszczą się poza dopuszczalnym zakresem bieżącego typu.
INumberBase<Char>.TryConvertToTruncating<TOther>(Char, TOther)	Próbuje przekonwertować wystąpienie bieżącego typu na inny typ, obcinając wszystkie wartości, które wykraczają poza reprezentowany zakres bieżącego typu.
INumberBase<Char>.TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Char)	Reprezentuje znak jako jednostkę kodu UTF-16.
INumberBase<Char>.TryParse(String, NumberStyles, IFormatProvider, Char)	Reprezentuje znak jako jednostkę kodu UTF-16.
INumberBase<Char>.Zero	Pobiera wartość 0 dla typu.
IParsable<Char>.Parse(String, IFormatProvider)	Analizuje ciąg w wartości.
IParsable<Char>.TryParse(String, IFormatProvider, Char)	Reprezentuje znak jako jednostkę kodu UTF-16.
IShiftOperators<Char,Int32,Char>.LeftShift(Char, Int32)	Przesuwa wartość pozostawioną przez daną kwotę.
IShiftOperators<Char,Int32,Char>.RightShift(Char, Int32)	Przesuwa wartość w prawo o daną kwotę.
IShiftOperators<Char,Int32,Char>.UnsignedRightShift(Char, Int32)	Przesuwa wartość w prawo o daną kwotę.
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Próbuje sformatować wartość bieżącego wystąpienia w podanym zakresie znaków.
ISpanParsable<Char>.Parse(ReadOnlySpan<Char>, IFormatProvider)	Analizuje zakres znaków w wartości.
ISpanParsable<Char>.TryParse(ReadOnlySpan<Char>, IFormatProvider, Char)	Reprezentuje znak jako jednostkę kodu UTF-16.
ISubtractionOperators<Char,Char,Char>.CheckedSubtraction(Char, Char)	Odejmuje dwie wartości, aby obliczyć ich różnicę.
ISubtractionOperators<Char,Char,Char>.Subtraction(Char, Char)	Odejmuje dwie wartości, aby obliczyć ich różnicę.
IUnaryNegationOperators<Char,Char>.CheckedUnaryNegation(Char)	Oblicza sprawdzoną jednoargumentową negację wartości.
IUnaryNegationOperators<Char,Char>.UnaryNegation(Char)	Oblicza jednoargumentowe negację wartości.
IUnaryPlusOperators<Char,Char>.UnaryPlus(Char)	Oblicza jednoargumentowy plus wartość.
IUtf8SpanFormattable.TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Próbuje sformatować wartość bieżącego wystąpienia jako UTF-8 w podanym zakresie bajtów.

Bezpieczeństwo wątkowe

Wszyscy członkowie tego typu są bezpieczni wątkami. Elementy członkowskie, które wydają się modyfikować stan wystąpienia, zwracają nowe wystąpienie zainicjowane przy użyciu nowej wartości. Podobnie jak w przypadku dowolnego innego typu odczyt i zapis w zmiennej udostępnionej, która zawiera wystąpienie tego typu, musi być chroniona przez blokadę, aby zagwarantować bezpieczeństwo wątków.

Zobacz też

• IComparable
• IConvertible
• String