Char Struktur

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Quelle:

Char.cs

Stellt ein Zeichen als UTF-16-Codeeinheit dar.

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)

Vererbung

Object

ValueType

Char

Implementiert

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>

Beispiele

Im folgenden Codebeispiel werden einige der Methoden in Charveranschaulicht.

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

Hinweise

Weitere Informationen zu dieser API finden Sie unter Ergänzende API-Hinweise für Char.

Felder

MaxValue	Stellt den größten möglichen Wert eines Chardar. Dieses Feld ist konstant.
MinValue	Stellt den kleinsten möglichen Wert eines Chardar. Dieses Feld ist konstant.

Methoden

CompareTo(Char)	Vergleicht diese Instanz mit einem angegebenen Char -Objekt und gibt an, ob diese Instanz vor, folgt oder in derselben Position in der Sortierreihenfolge wie das angegebene Char -Objekt angezeigt wird.
CompareTo(Object)	Vergleicht diese Instanz mit einem angegebenen Objekt und gibt an, ob diese Instanz vorgeht, folgt oder in derselben Position in der Sortierreihenfolge wie die angegebene Objectangezeigt wird.
ConvertFromUtf32(Int32)	Konvertiert den angegebenen Unicode-Codepunkt in eine UTF-16-codierte Zeichenfolge.
ConvertToUtf32(Char, Char)	Konvertiert den Wert eines UTF-16-codierten Ersatzpaars in einen Unicode-Codepunkt.
ConvertToUtf32(String, Int32)	Wandelt den Wert eines UTF-16-codierten Zeichen- oder Ersatzpaars an einer angegebenen Position in einer Zeichenfolge in einen Unicode-Codepunkt um.
Equals(Char)	Gibt einen Wert zurück, der angibt, ob diese Instanz dem angegebenen Char -Objekt entspricht.
Equals(Object)	Gibt einen Wert zurück, der angibt, ob diese Instanz einem angegebenen Objekt entspricht.
GetHashCode()	Gibt den Hashcode für diese Instanz zurück.
GetNumericValue(Char)	Konvertiert das angegebene numerische Unicode-Zeichen in eine Gleitkommazahl mit doppelter Genauigkeit.
GetNumericValue(String, Int32)	Konvertiert das numerische Unicode-Zeichen an der angegebenen Position in einer angegebenen Zeichenfolge in eine Gleitkommazahl mit doppelter Genauigkeit.
GetTypeCode()	Gibt den TypeCode für den Werttyp Charzurück.
GetUnicodeCategory(Char)	Kategorisiert ein angegebenes Unicode-Zeichen in eine Gruppe, die durch einen der UnicodeCategory Werte identifiziert wird.
GetUnicodeCategory(String, Int32)	Kategorisiert das Zeichen an der angegebenen Position in einer angegebenen Zeichenfolge in eine Gruppe, die durch einen der UnicodeCategory Werte identifiziert wird.
IsAscii(Char)	Gibt true zurück, wenn c ein ASCII-Zeichen ist ([ U+0000.U+007F ]).
IsAsciiDigit(Char)	Gibt an, ob ein Zeichen als ASCII-Ziffer kategorisiert wird.
IsAsciiHexDigit(Char)	Gibt an, ob ein Zeichen als hexademische ASCII-Ziffer kategorisiert wird.
IsAsciiHexDigitLower(Char)	Gibt an, ob ein Zeichen als ASCII-Hexademieziffer kategorisiert wird.
IsAsciiHexDigitUpper(Char)	Gibt an, ob ein Zeichen als hexademische ASCII-Ziffer kategorisiert wird.
IsAsciiLetter(Char)	Gibt an, ob ein Zeichen als ASCII-Buchstabe kategorisiert wird.
IsAsciiLetterLower(Char)	Gibt an, ob ein Zeichen als kleingeschriebener ASCII-Buchstabe kategorisiert wird.
IsAsciiLetterOrDigit(Char)	Gibt an, ob ein Zeichen als ASCII-Buchstabe oder Ziffern kategorisiert wird.
IsAsciiLetterUpper(Char)	Gibt an, ob ein Zeichen als ASCII-Großbuchstaben kategorisiert wird.
IsBetween(Char, Char, Char)	Gibt an, ob sich ein Zeichen innerhalb des angegebenen inklusiven Bereichs befindet.
IsControl(Char)	Gibt an, ob das angegebene Unicode-Zeichen als Steuerelementzeichen kategorisiert wird.
IsControl(String, Int32)	Gibt an, ob das Zeichen an der angegebenen Position in einer angegebenen Zeichenfolge als Steuerelementzeichen kategorisiert wird.
IsDigit(Char)	Gibt an, ob das angegebene Unicode-Zeichen als Dezimalziffer kategorisiert wird.
IsDigit(String, Int32)	Gibt an, ob das Zeichen an der angegebenen Position in einer angegebenen Zeichenfolge als Dezimalziffer kategorisiert wird.
IsHighSurrogate(Char)	Gibt an, ob das angegebene Char-Objekt ein hoher Ersatz ist.
IsHighSurrogate(String, Int32)	Gibt an, ob das Char -Objekt an der angegebenen Position in einer Zeichenfolge ein hohes Ersatzobjekt ist.
IsLetter(Char)	Gibt an, ob das angegebene Unicode-Zeichen als Unicode-Buchstabe kategorisiert wird.
IsLetter(String, Int32)	Gibt an, ob das Zeichen an der angegebenen Position in einer angegebenen Zeichenfolge als Unicode-Buchstabe kategorisiert wird.
IsLetterOrDigit(Char)	Gibt an, ob das angegebene Unicode-Zeichen als Buchstabe oder dezimale Ziffer kategorisiert wird.
IsLetterOrDigit(String, Int32)	Gibt an, ob das Zeichen an der angegebenen Position in einer angegebenen Zeichenfolge als Buchstabe oder Dezimalziffer kategorisiert wird.
IsLower(Char)	Gibt an, ob das angegebene Unicode-Zeichen als Kleinbuchstaben kategorisiert wird.
IsLower(String, Int32)	Gibt an, ob das Zeichen an der angegebenen Position in einer angegebenen Zeichenfolge als Kleinbuchstabe kategorisiert wird.
IsLowSurrogate(Char)	Gibt an, ob das angegebene Char -Objekt ein niedriger Ersatz ist.
IsLowSurrogate(String, Int32)	Gibt an, ob das Char -Objekt an der angegebenen Position in einer Zeichenfolge ein niedriger Ersatz ist.
IsNumber(Char)	Gibt an, ob das angegebene Unicode-Zeichen als Zahl kategorisiert wird.
IsNumber(String, Int32)	Gibt an, ob das Zeichen an der angegebenen Position in einer angegebenen Zeichenfolge als Zahl kategorisiert wird.
IsPunctuation(Char)	Gibt an, ob das angegebene Unicode-Zeichen als Interpunktionszeichen kategorisiert wird.
IsPunctuation(String, Int32)	Gibt an, ob das Zeichen an der angegebenen Position in einer angegebenen Zeichenfolge als Satzzeichen kategorisiert wird.
IsSeparator(Char)	Gibt an, ob das angegebene Unicode-Zeichen als Trennzeichen kategorisiert wird.
IsSeparator(String, Int32)	Gibt an, ob das Zeichen an der angegebenen Position in einer angegebenen Zeichenfolge als Trennzeichen kategorisiert wird.
IsSurrogate(Char)	Gibt an, ob das angegebene Zeichen über eine Ersatzcodeeinheit verfügt.
IsSurrogate(String, Int32)	Gibt an, ob das Zeichen an der angegebenen Position in einer angegebenen Zeichenfolge eine Ersatzcodeeinheit aufweist.
IsSurrogatePair(Char, Char)	Gibt an, ob die beiden angegebenen Char Objekte ein Ersatzpaar bilden.
IsSurrogatePair(String, Int32)	Gibt an, ob zwei angrenzende Char Objekte an einer angegebenen Position in einer Zeichenfolge ein Ersatzpaar bilden.
IsSymbol(Char)	Gibt an, ob das angegebene Unicode-Zeichen als Symbolzeichen kategorisiert wird.
IsSymbol(String, Int32)	Gibt an, ob das Zeichen an der angegebenen Position in einer angegebenen Zeichenfolge als Symbolzeichen kategorisiert wird.
IsUpper(Char)	Gibt an, ob das angegebene Unicode-Zeichen als Großbuchstaben kategorisiert wird.
IsUpper(String, Int32)	Gibt an, ob das Zeichen an der angegebenen Position in einer angegebenen Zeichenfolge als Großbuchstaben kategorisiert wird.
IsWhiteSpace(Char)	Gibt an, ob das angegebene Unicode-Zeichen als Leerzeichen kategorisiert wird.
IsWhiteSpace(String, Int32)	Gibt an, ob das Zeichen an der angegebenen Position in einer angegebenen Zeichenfolge als Leerzeichen kategorisiert wird.
Parse(String)	Konvertiert den Wert der angegebenen Zeichenfolge in das entsprechende Unicode-Zeichen.
ToLower(Char)	Wandelt den Wert eines Unicode-Zeichens in seine Kleinbuchstaben-Entsprechung um.
ToLower(Char, CultureInfo)	Wandelt den Wert eines angegebenen Unicode-Zeichens in sein Kleinbuchstaben-Äquivalent mithilfe der angegebenen kulturspezifischen Formatierungsinformationen um.
ToLowerInvariant(Char)	Wandelt den Wert eines Unicode-Zeichens mithilfe der Groß-/Kleinschreibungsregeln der invarianten Kultur in das Kleinbuchstabe um.
ToString()	Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung.
ToString(Char)	Konvertiert das angegebene Unicode-Zeichen in die entsprechende Zeichenfolgendarstellung.
ToString(IFormatProvider)	Wandelt den Wert dieser Instanz mithilfe der angegebenen kulturspezifischen Formatinformationen in die entsprechende Zeichenfolgendarstellung um.
ToUpper(Char)	Wandelt den Wert eines Unicode-Zeichens in seine Großbuchstaben-Entsprechung um.
ToUpper(Char, CultureInfo)	Konvertiert den Wert eines angegebenen Unicode-Zeichens in das großgeschriebene Äquivalent mithilfe der angegebenen kulturspezifischen Formatierungsinformationen.
ToUpperInvariant(Char)	Wandelt den Wert eines Unicode-Zeichens mithilfe der Groß-/Kleinschreibung der invarianten Kultur in die großgeschriebene Entsprechung um.
TryParse(String, Char)	Konvertiert den Wert der angegebenen Zeichenfolge in das entsprechende Unicode-Zeichen. Ein Rückgabecode gibt an, ob die Konvertierung erfolgreich war oder fehlgeschlagen ist.

Explizite Schnittstellenimplementierungen

IAdditionOperators<Char,Char,Char>.Addition(Char, Char)	Addiert zwei Werte zusammen, um ihre Summe zu berechnen.
IAdditionOperators<Char,Char,Char>.CheckedAddition(Char, Char)	Addiert zwei Werte zusammen, um ihre Summe zu berechnen.
IAdditiveIdentity<Char,Char>.AdditiveIdentity	Ruft die additive Identität des aktuellen Typs ab.
IBinaryInteger<Char>.GetByteCount()	Ruft die Anzahl der Bytes ab, die als Teil von TryWriteLittleEndian(Span<Byte>, Int32)geschrieben werden.
IBinaryInteger<Char>.GetShortestBitLength()	Ruft die Länge in Bits der kürzesten beiden Ergänzungsdarstellung des aktuellen Werts ab.
IBinaryInteger<Char>.LeadingZeroCount(Char)	Berechnet die Anzahl der führenden Nullbits in einem Wert.
IBinaryInteger<Char>.PopCount(Char)	Berechnet die Anzahl der Bits, die in einem Wert festgelegt sind.
IBinaryInteger<Char>.RotateLeft(Char, Int32)	Dreht einen Wert um einen bestimmten Betrag nach links.
IBinaryInteger<Char>.RotateRight(Char, Int32)	Dreht einen Wert um einen bestimmten Betrag nach rechts.
IBinaryInteger<Char>.TrailingZeroCount(Char)	Berechnet die Anzahl der nachfolgenden Nullbits in einem Wert.
IBinaryInteger<Char>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Char)	Stellt ein Zeichen als UTF-16-Codeeinheit dar.
IBinaryInteger<Char>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Char)	Stellt ein Zeichen als UTF-16-Codeeinheit dar.
IBinaryInteger<Char>.TryWriteBigEndian(Span<Byte>, Int32)	Versucht, den aktuellen Wert im Big-End-Format in einen bestimmten Bereich zu schreiben.
IBinaryInteger<Char>.TryWriteLittleEndian(Span<Byte>, Int32)	Versucht, den aktuellen Wert in einem kleinen endischen Format in einen bestimmten Bereich zu schreiben.
IBinaryNumber<Char>.AllBitsSet	Ruft eine Instanz des binären Typs ab, in der alle Bits festgelegt sind.
IBinaryNumber<Char>.IsPow2(Char)	Bestimmt, ob ein Wert eine Potenz von zwei ist.
IBinaryNumber<Char>.Log2(Char)	Berechnet das Protokoll2 eines Werts.
IBitwiseOperators<Char,Char,Char>.BitwiseAnd(Char, Char)	Berechnet die bitweise und von zwei Werten.
IBitwiseOperators<Char,Char,Char>.BitwiseOr(Char, Char)	Berechnet die bitweise oder zwei Werte.
IBitwiseOperators<Char,Char,Char>.ExclusiveOr(Char, Char)	Berechnet die exklusiven oder zwei Werte.
IBitwiseOperators<Char,Char,Char>.OnesComplement(Char)	Berechnet die Darstellung eines bestimmten Werts.
IComparisonOperators<Char,Char,Boolean>.GreaterThan(Char, Char)	Vergleicht zwei Werte, um zu bestimmen, welche größer ist.
IComparisonOperators<Char,Char,Boolean>.GreaterThanOrEqual(Char, Char)	Vergleicht zwei Werte, um zu bestimmen, welche größer oder gleich sind.
IComparisonOperators<Char,Char,Boolean>.LessThan(Char, Char)	Vergleicht zwei Werte, um zu bestimmen, welche werte kleiner sind.
IComparisonOperators<Char,Char,Boolean>.LessThanOrEqual(Char, Char)	Vergleicht zwei Werte, um zu bestimmen, welche kleiner oder gleich ist.
IConvertible.ToBoolean(IFormatProvider)	Hinweis Diese Konvertierung wird nicht unterstützt. Wenn Sie versuchen, dies zu tun, wird eine InvalidCastExceptionausgelöst.
IConvertible.ToByte(IFormatProvider)	Eine Beschreibung dieses Mitglieds finden Sie unter ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Eine Beschreibung dieses Mitglieds finden Sie unter ToChar(IFormatProvider).
IConvertible.ToDateTime(IFormatProvider)	Hinweis Diese Konvertierung wird nicht unterstützt. Wenn Sie versuchen, dies zu tun, wird eine InvalidCastExceptionausgelöst.
IConvertible.ToDecimal(IFormatProvider)	Hinweis Diese Konvertierung wird nicht unterstützt. Wenn Sie versuchen, dies zu tun, wird eine InvalidCastExceptionausgelöst.
IConvertible.ToDouble(IFormatProvider)	Hinweis Diese Konvertierung wird nicht unterstützt. Wenn Sie versuchen, dies zu tun, wird eine InvalidCastExceptionausgelöst.
IConvertible.ToInt16(IFormatProvider)	Eine Beschreibung dieses Mitglieds finden Sie unter ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Eine Beschreibung dieses Mitglieds finden Sie unter ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Eine Beschreibung dieses Mitglieds finden Sie unter ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Eine Beschreibung dieses Mitglieds finden Sie unter ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Hinweis Diese Konvertierung wird nicht unterstützt. Wenn Sie versuchen, dies zu tun, wird eine InvalidCastExceptionausgelöst.
IConvertible.ToType(Type, IFormatProvider)	Eine Beschreibung dieses Mitglieds finden Sie unter ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Eine Beschreibung dieses Mitglieds finden Sie unter ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Eine Beschreibung dieses Mitglieds finden Sie unter ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Eine Beschreibung dieses Mitglieds finden Sie unter ToUInt64(IFormatProvider).
IDecrementOperators<Char>.CheckedDecrement(Char)	Erhöht einen Wert.
IDecrementOperators<Char>.Decrement(Char)	Erhöht einen Wert.
IDivisionOperators<Char,Char,Char>.Division(Char, Char)	Dividiert einen Wert durch einen anderen, um seinen Quotienten zu berechnen.
IEqualityOperators<Char,Char,Boolean>.Equality(Char, Char)	Vergleicht zwei Werte, um die Gleichheit zu bestimmen.
IEqualityOperators<Char,Char,Boolean>.Inequality(Char, Char)	Vergleicht zwei Werte zur Bestimmung der Ungleichheit.
IFormattable.ToString(String, IFormatProvider)	Formatiert den Wert der aktuellen Instanz mithilfe des angegebenen Formats.
IIncrementOperators<Char>.CheckedIncrement(Char)	Erhöht einen Wert.
IIncrementOperators<Char>.Increment(Char)	Erhöht einen Wert.
IMinMaxValue<Char>.MaxValue	Ruft den Maximalwert des aktuellen Typs ab.
IMinMaxValue<Char>.MinValue	Ruft den Minimalwert des aktuellen Typs ab.
IModulusOperators<Char,Char,Char>.Modulus(Char, Char)	Dividiert zwei Werte zusammen, um deren Modul oder Rest zu berechnen.
IMultiplicativeIdentity<Char,Char>.MultiplicativeIdentity	Ruft die multiplizierte Identität des aktuellen Typs ab.
IMultiplyOperators<Char,Char,Char>.CheckedMultiply(Char, Char)	Multipliziert zwei Werte zusammen, um ihr Produkt zu berechnen.
IMultiplyOperators<Char,Char,Char>.Multiply(Char, Char)	Multipliziert zwei Werte zusammen, um ihr Produkt zu berechnen.
INumberBase<Char>.Abs(Char)	Berechnet den absoluten Wert.
INumberBase<Char>.IsCanonical(Char)	Bestimmt, ob sich ein Wert in seiner kanonischen Darstellung befindet.
INumberBase<Char>.IsComplexNumber(Char)	Bestimmt, ob ein Wert eine komplexe Zahl darstellt.
INumberBase<Char>.IsEvenInteger(Char)	Bestimmt, ob ein Wert eine gerade integrale Zahl darstellt.
INumberBase<Char>.IsFinite(Char)	Bestimmt, ob ein Wert endlich ist.
INumberBase<Char>.IsImaginaryNumber(Char)	Bestimmt, ob ein Wert eine reine imaginäre Zahl darstellt.
INumberBase<Char>.IsInfinity(Char)	Bestimmt, ob ein Wert unendlich ist.
INumberBase<Char>.IsInteger(Char)	Bestimmt, ob ein Wert eine integrale Zahl darstellt.
INumberBase<Char>.IsNaN(Char)	Bestimmt, ob ein Wert NaN ist.
INumberBase<Char>.IsNegative(Char)	Bestimmt, ob ein Wert negativ ist.
INumberBase<Char>.IsNegativeInfinity(Char)	Bestimmt, ob ein Wert negative Unendlichkeit ist.
INumberBase<Char>.IsNormal(Char)	Bestimmt, ob ein Wert normal ist.
INumberBase<Char>.IsOddInteger(Char)	Bestimmt, ob ein Wert eine ungerade integrale Zahl darstellt.
INumberBase<Char>.IsPositive(Char)	Bestimmt, ob ein Wert positiv ist.
INumberBase<Char>.IsPositiveInfinity(Char)	Bestimmt, ob ein Wert positive Unendlichkeit ist.
INumberBase<Char>.IsRealNumber(Char)	Bestimmt, ob ein Wert eine reelle Zahl darstellt.
INumberBase<Char>.IsSubnormal(Char)	Bestimmt, ob ein Wert subnormal ist.
INumberBase<Char>.IsZero(Char)	Bestimmt, ob ein Wert null ist.
INumberBase<Char>.MaxMagnitude(Char, Char)	Vergleicht zwei Werte mit der Berechnung, die größer ist.
INumberBase<Char>.MaxMagnitudeNumber(Char, Char)	Vergleicht zwei Werte mit der Berechnung, die größer ist und den anderen Wert zurückgibt, wenn eine Eingabe NaNist.
INumberBase<Char>.MinMagnitude(Char, Char)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist.
INumberBase<Char>.MinMagnitudeNumber(Char, Char)	Vergleicht zwei Werte mit der Berechnung, die die geringere Größe aufweist und den anderen Wert zurückgibt, wenn eine Eingabe NaNist.
INumberBase<Char>.One	Ruft den Wert 1 für den Typ ab.
INumberBase<Char>.Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Analysiert eine Spanne von Zeichen in einen Wert.
INumberBase<Char>.Parse(String, NumberStyles, IFormatProvider)	Analysiert eine Zeichenfolge in einen Wert.
INumberBase<Char>.Radix	Ruft das Radix oder die Basis für den Typ ab.
INumberBase<Char>.TryConvertFromChecked<TOther>(TOther, Char)	Stellt ein Zeichen als UTF-16-Codeeinheit dar.
INumberBase<Char>.TryConvertFromSaturating<TOther>(TOther, Char)	Stellt ein Zeichen als UTF-16-Codeeinheit dar.
INumberBase<Char>.TryConvertFromTruncating<TOther>(TOther, Char)	Stellt ein Zeichen als UTF-16-Codeeinheit dar.
INumberBase<Char>.TryConvertToChecked<TOther>(Char, TOther)	Versucht, eine Instanz des aktuellen Typs in einen anderen Typ zu konvertieren und löst eine Überlaufausnahme für alle Werte aus, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<Char>.TryConvertToSaturating<TOther>(Char, TOther)	Versucht, eine Instanz des aktuellen Typs in einen anderen Typ zu konvertieren und alle Werte zu sättigungen, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<Char>.TryConvertToTruncating<TOther>(Char, TOther)	Versucht, eine Instanz des aktuellen Typs in einen anderen Typ zu konvertieren, wobei alle Werte abgeschnitten werden, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<Char>.TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Char)	Stellt ein Zeichen als UTF-16-Codeeinheit dar.
INumberBase<Char>.TryParse(String, NumberStyles, IFormatProvider, Char)	Stellt ein Zeichen als UTF-16-Codeeinheit dar.
INumberBase<Char>.Zero	Ruft den Wert 0 für den Typ ab.
IParsable<Char>.Parse(String, IFormatProvider)	Analysiert eine Zeichenfolge in einen Wert.
IParsable<Char>.TryParse(String, IFormatProvider, Char)	Stellt ein Zeichen als UTF-16-Codeeinheit dar.
IShiftOperators<Char,Int32,Char>.LeftShift(Char, Int32)	Verschiebt einen Wert um einen bestimmten Betrag nach links.
IShiftOperators<Char,Int32,Char>.RightShift(Char, Int32)	Verschiebt einen Wert um einen bestimmten Betrag nach rechts.
IShiftOperators<Char,Int32,Char>.UnsignedRightShift(Char, Int32)	Verschiebt einen Wert um einen bestimmten Betrag nach rechts.
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Versucht, den Wert der aktuellen Instanz in die bereitgestellte Zeichenspanne zu formatieren.
ISpanParsable<Char>.Parse(ReadOnlySpan<Char>, IFormatProvider)	Analysiert eine Spanne von Zeichen in einen Wert.
ISpanParsable<Char>.TryParse(ReadOnlySpan<Char>, IFormatProvider, Char)	Stellt ein Zeichen als UTF-16-Codeeinheit dar.
ISubtractionOperators<Char,Char,Char>.CheckedSubtraction(Char, Char)	Subtrahiert zwei Werte, um ihre Differenz zu berechnen.
ISubtractionOperators<Char,Char,Char>.Subtraction(Char, Char)	Subtrahiert zwei Werte, um ihre Differenz zu berechnen.
IUnaryNegationOperators<Char,Char>.CheckedUnaryNegation(Char)	Berechnet die überprüfte unäre Negation eines Werts.
IUnaryNegationOperators<Char,Char>.UnaryNegation(Char)	Berechnet die unäre Negation eines Werts.
IUnaryPlusOperators<Char,Char>.UnaryPlus(Char)	Berechnet das unäre Pluszeichen eines Werts.
IUtf8SpanFormattable.TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Versucht, den Wert der aktuellen Instanz als UTF-8 in die bereitgestellte Bytespanne zu formatieren.

Threadsicherheit

Alle Elemente dieses Typs sind threadsicher. Elemente, die den Instanzstatus ändern möchten, geben tatsächlich eine neue Instanz zurück, die mit dem neuen Wert initialisiert wurde. Wie bei jedem anderen Typ muss das Lesen und Schreiben in eine freigegebene Variable, die eine Instanz dieses Typs enthält, durch eine Sperre geschützt werden, um die Threadsicherheit zu gewährleisten.

Weitere Informationen

• IComparable
• IConvertible
• String