Char Struktur

Definition

Stellt ein Zeichen als UTF-16-Codeeinheit dar.

public value class char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
public value class char : IComparable, IComparable<char>, IConvertible, IEquatable<char>, ISpanFormattable
public value class char : IComparable<char>, IConvertible, IEquatable<char>, IParsable<char>, ISpanParsable<char>, System::Numerics::IAdditionOperators<char, char, char>, System::Numerics::IAdditiveIdentity<char, char>, System::Numerics::IBinaryInteger<char>, System::Numerics::IBinaryNumber<char>, System::Numerics::IBitwiseOperators<char, char, char>, System::Numerics::IComparisonOperators<char, char, bool>, System::Numerics::IDecrementOperators<char>, System::Numerics::IDivisionOperators<char, char, char>, System::Numerics::IEqualityOperators<char, char, bool>, System::Numerics::IIncrementOperators<char>, System::Numerics::IMinMaxValue<char>, System::Numerics::IModulusOperators<char, char, char>, System::Numerics::IMultiplicativeIdentity<char, char>, System::Numerics::IMultiplyOperators<char, char, char>, System::Numerics::INumber<char>, System::Numerics::INumberBase<char>, System::Numerics::IShiftOperators<char, int, char>, System::Numerics::ISubtractionOperators<char, char, char>, System::Numerics::IUnaryNegationOperators<char, char>, System::Numerics::IUnaryPlusOperators<char, char>, System::Numerics::IUnsignedNumber<char>
public 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 value class char : IComparable, IConvertible
public value class char : IComparable, IComparable<char>, IEquatable<char>
public struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
public readonly struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
public readonly struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>, ISpanFormattable
public readonly struct Char : IComparable<char>, IConvertible, IEquatable<char>, IParsable<char>, ISpanParsable<char>, System.Numerics.IAdditionOperators<char,char,char>, System.Numerics.IAdditiveIdentity<char,char>, System.Numerics.IBinaryInteger<char>, System.Numerics.IBinaryNumber<char>, System.Numerics.IBitwiseOperators<char,char,char>, System.Numerics.IComparisonOperators<char,char,bool>, System.Numerics.IDecrementOperators<char>, System.Numerics.IDivisionOperators<char,char,char>, System.Numerics.IEqualityOperators<char,char,bool>, System.Numerics.IIncrementOperators<char>, System.Numerics.IMinMaxValue<char>, System.Numerics.IModulusOperators<char,char,char>, System.Numerics.IMultiplicativeIdentity<char,char>, System.Numerics.IMultiplyOperators<char,char,char>, System.Numerics.INumber<char>, System.Numerics.INumberBase<char>, System.Numerics.IShiftOperators<char,int,char>, System.Numerics.ISubtractionOperators<char,char,char>, System.Numerics.IUnaryNegationOperators<char,char>, System.Numerics.IUnaryPlusOperators<char,char>, System.Numerics.IUnsignedNumber<char>
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>
[System.Serializable]
public struct Char : IComparable, IConvertible
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
public struct Char : IComparable, IComparable<char>, IEquatable<char>
type char = struct
    interface IConvertible
type char = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable
type char = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<char>
    interface ISpanFormattable
    interface ISpanParsable<char>
    interface IAdditionOperators<char, char, char>
    interface IAdditiveIdentity<char, char>
    interface IBinaryInteger<char>
    interface IBinaryNumber<char>
    interface IBitwiseOperators<char, char, char>
    interface IComparisonOperators<char, char, bool>
    interface IEqualityOperators<char, char, bool>
    interface IDecrementOperators<char>
    interface IDivisionOperators<char, char, char>
    interface IIncrementOperators<char>
    interface IModulusOperators<char, char, char>
    interface IMultiplicativeIdentity<char, char>
    interface IMultiplyOperators<char, char, char>
    interface INumber<char>
    interface INumberBase<char>
    interface ISubtractionOperators<char, char, char>
    interface IUnaryNegationOperators<char, char>
    interface IUnaryPlusOperators<char, char>
    interface IShiftOperators<char, int, char>
    interface IMinMaxValue<char>
    interface IUnsignedNumber<char>
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>
[<System.Serializable>]
type char = struct
    interface IConvertible
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type char = struct
    interface IConvertible
type char = struct
Public Structure Char
Implements IComparable, IComparable(Of Char), IConvertible, IEquatable(Of Char)
Public Structure Char
Implements IComparable, IComparable(Of Char), IConvertible, IEquatable(Of Char), ISpanFormattable
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)
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)
Public Structure Char
Implements IComparable, IConvertible
Public Structure Char
Implements IComparable, IComparable(Of Char), IEquatable(Of Char)
Vererbung
Attribute
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 Zusätzliche API-Hinweise für Char.

Felder

MaxValue

Stellt den größtmöglichen Wert von Char dar. Dieses Feld ist konstant.

MinValue

Stellt den kleinstmöglichen Wert von Char dar. Dieses Feld ist konstant.

Methoden

CompareTo(Char)

Vergleicht diese Instanz mit einem angegebenen Char-Objekt und gibt an, ob diese Instanz in der Sortierreihenfolge an einer früheren, späteren oder derselben Position wie das angegebene Char-Objekt aufgeführt wird.

CompareTo(Object)

Vergleicht diese Instanz mit einem angegebenen Objekt und gibt an, ob diese Instanz in der Sortierreihenfolge an einer früheren, späteren oder derselben Position wie das angegebene Object aufgeführt wird.

ConvertFromUtf32(Int32)

Konvertiert den angegebenen Unicode-Codepunkt in eine UTF-16-codierte Zeichenfolge.

ConvertToUtf32(Char, Char)

Konvertiert den Wert eines UTF-16-codierten Ersatzzeichenpaars in einen Unicode-Codepunkt.

ConvertToUtf32(String, Int32)

Konvertiert den Wert eines UTF-16-codierten Zeichens oder Ersatzzeichenpaars an der angegebenen Position in einer Zeichenfolge in einen Unicode-Codepunkt.

Equals(Char)

Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Char-Objekt ist.

Equals(Object)

Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.

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 Char zurück.

GetUnicodeCategory(Char)

Kategorisiert ein angegebenes Unicode-Zeichen in einer Gruppe, die durch einen der UnicodeCategory-Werte bezeichnet wird.

GetUnicodeCategory(String, Int32)

Kategorisiert das Zeichen an der angegebenen Position in einer angegebenen Zeichenfolge in einer Gruppe, die durch einen der UnicodeCategory-Werte bezeichnet wird.

IsAscii(Char)

Gibt zurück true , wenn c ein ASCII-Zeichen ([ U+0000..U+007F ]) ist.

IsAsciiDigit(Char)

Gibt an, ob ein Zeichen als ASCII-Ziffer kategorisiert wird.

IsAsciiHexDigit(Char)

Gibt an, ob ein Zeichen als ASCII-hexademische Ziffer kategorisiert wird.

IsAsciiHexDigitLower(Char)

Gibt an, ob ein Zeichen als ASCII-Hexadezimalziffer in Kleinbuchstaben kategorisiert wird.

IsAsciiHexDigitUpper(Char)

Gibt an, ob ein Zeichen als ASCII-Hexadezimalziffer in Großbuchstaben kategorisiert wird.

IsAsciiLetter(Char)

Gibt an, ob ein Zeichen als ASCII-Buchstabe kategorisiert ist.

IsAsciiLetterLower(Char)

Gibt an, ob ein Zeichen als ASCII-Kleinbuchstaben kategorisiert wird.

IsAsciiLetterOrDigit(Char)

Gibt an, ob ein Zeichen als ASCII-Buchstabe oder -Ziffer 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 Steuerzeichen kategorisiert wird.

IsControl(String, Int32)

Gibt an, ob das Zeichen an der angegebenen Position in einer angegebenen Zeichenfolge als Steuerzeichen kategorisiert wird.

IsDigit(Char)

Gibt an, ob das angegebene Unicode-Zeichen als Dezimalzahl kategorisiert wird.

IsDigit(String, Int32)

Gibt an, ob das Zeichen an der angegebenen Position in einer angegebenen Zeichenfolge als Dezimalzahl kategorisiert wird.

IsHighSurrogate(Char)

Gibt an, ob das angegebene Char-Objekt ein hohes Ersatzzeichen ist.

IsHighSurrogate(String, Int32)

Gibt an, ob das Char-Objekt an der angegebenen Position in einer Zeichenfolge ein hohes Ersatzzeichen 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 als Dezimalzahl kategorisiert wird.

IsLetterOrDigit(String, Int32)

Gibt an, ob das Zeichen an der angegebenen Position in einer angegebenen Zeichenfolge als Buchstabe oder Dezimalzahl kategorisiert wird.

IsLower(Char)

Gibt an, ob das angegebene Unicode-Zeichen als Kleinbuchstabe 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 niedriges Ersatzzeichen ist.

IsLowSurrogate(String, Int32)

Gibt an, ob das Char-Objekt an der angegebenen Position in einer Zeichenfolge ein niedriges Ersatzzeichen 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 Satzzeichen 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 ein angegebenes 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 einen Ersatzzeichencodeeinheit verfügt.

IsSurrogate(String, Int32)

Gibt an, ob das Zeichen an der angegebenen Position in einer angegebenen Zeichenfolge über einen Ersatzzeichen-Codeeinheit verfügt.

IsSurrogatePair(Char, Char)

Gibt an, ob die beiden angegebenen Char-Objekte ein Ersatzzeichenpaar bilden.

IsSurrogatePair(String, Int32)

Gibt an, ob zwei aufeinander folgende Char-Objekte an einer angegebenen Position in einer Zeichenfolge ein Ersatzzeichenpaar bilden.

IsSymbol(Char)

Gibt an, ob ein angegebenes 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 ein angegebenes Unicode-Zeichen als Großbuchstabe kategorisiert wird.

IsUpper(String, Int32)

Gibt an, ob das Zeichen an der angegebenen Position in einer angegebenen Zeichenfolge als Großbuchstabe 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)

Konvertiert den Wert eines Unicode-Zeichens in den entsprechenden Kleinbuchstaben.

ToLower(Char, CultureInfo)

Konvertiert den Wert eines angegebenen Unicode-Zeichens unter Verwendung der angegebenen kulturabhängigen Formatierungsinformationen in den entsprechenden Kleinbuchstaben.

ToLowerInvariant(Char)

Konvertiert den Wert eines Unicode-Zeichens in dessen Entsprechung in Kleinbuchstaben unter Verwendung der Regeln der invarianten Kultur für Groß- und Kleinschreibung.

ToString()

Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung.

ToString(Char)

Konvertiert das angegebene Unicode-Zeichen in die entsprechende Zeichenfolgendarstellung.

ToString(IFormatProvider)

Konvertiert den Wert dieser Instanz unter Verwendung der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgenentsprechung.

ToUpper(Char)

Konvertiert den Wert eines Unicode-Zeichens in den entsprechenden Großbuchstaben.

ToUpper(Char, CultureInfo)

Konvertiert den Wert eines angegebenen Unicode-Zeichens unter Verwendung der angegebenen kulturabhängigen Formatierungsinformationen in den entsprechenden Großbuchstaben.

ToUpperInvariant(Char)

Konvertiert den Wert eines Unicode-Zeichens in dessen Entsprechung in Großbuchstaben unter Verwendung der Regeln der invarianten Kultur für Groß- und Kleinschreibung.

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

Explizite Schnittstellenimplementierungen

IAdditionOperators<Char,Char,Char>.Addition(Char, Char)

Fügt zwei Werte zusammen, um ihre Summe zu berechnen.

IAdditionOperators<Char,Char,Char>.CheckedAddition(Char, Char)

Fügt 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 der Komplementdarstellung des aktuellen Werts in Bits 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)

Rotiert einen Wert, der um einen bestimmten Betrag verlassen wird.

IBinaryInteger<Char>.RotateRight(Char, Int32)

Rotiert einen Wert nach rechts um einen bestimmten Betrag.

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 eine bestimmte Spanne zu schreiben.

IBinaryInteger<Char>.TryWriteLittleEndian(Span<Byte>, Int32)

Versucht, den aktuellen Wert im Little-Endian-Format in eine bestimmte Spanne zu schreiben.

IBinaryNumber<Char>.AllBitsSet

Ruft eine instance des Binärtyps ab, in dem alle Bits festgelegt sind.

IBinaryNumber<Char>.IsPow2(Char)

Bestimmt, ob ein Wert eine Macht von zwei ist.

IBinaryNumber<Char>.Log2(Char)

Berechnet das protokoll2 eines Werts.

IBitwiseOperators<Char,Char,Char>.BitwiseAnd(Char, Char)

Berechnet den bitweisen und von zwei Werten.

IBitwiseOperators<Char,Char,Char>.BitwiseOr(Char, Char)

Berechnet den bitweisen oder von zwei Werten.

IBitwiseOperators<Char,Char,Char>.ExclusiveOr(Char, Char)

Berechnet den exklusiven oder von zwei Werten.

IBitwiseOperators<Char,Char,Char>.OnesComplement(Char)

Berechnet die Eins-Komplement-Darstellung eines bestimmten Werts.

IComparable.CompareTo(Object)

Vergleicht die aktuelle Instanz mit einem anderen Objekt vom selben Typ und gibt eine ganze Zahl zurück, die angibt, ob die aktuelle Instanz in der Sortierreihenfolge vor oder nach dem anderen Objekt oder an derselben Position auftritt.

IComparisonOperators<Char,Char,Boolean>.GreaterThan(Char, Char)

Vergleicht zwei Werte, um zu ermitteln, welcher 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 ermitteln, welcher kleiner ist.

IComparisonOperators<Char,Char,Boolean>.LessThanOrEqual(Char, Char)

Vergleicht zwei Werte, um zu bestimmen, welche kleiner oder gleich sind.

IConvertible.GetTypeCode()

Gibt den TypeCode für diese Instanz zurück.

IConvertible.ToBoolean(IFormatProvider)

Hinweis Diese Konvertierung wird nicht unterstützt. Bei einem entsprechenden Versuch wird eine InvalidCastException ausgelöst.

IConvertible.ToByte(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToChar(IFormatProvider).

IConvertible.ToDateTime(IFormatProvider)

Hinweis Diese Konvertierung wird nicht unterstützt. Bei einem entsprechenden Versuch wird eine InvalidCastException ausgelöst.

IConvertible.ToDecimal(IFormatProvider)

Hinweis Diese Konvertierung wird nicht unterstützt. Bei einem entsprechenden Versuch wird eine InvalidCastException ausgelöst.

IConvertible.ToDouble(IFormatProvider)

Hinweis Diese Konvertierung wird nicht unterstützt. Bei einem entsprechenden Versuch wird eine InvalidCastException ausgelöst.

IConvertible.ToInt16(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider)

Hinweis Diese Konvertierung wird nicht unterstützt. Bei einem entsprechenden Versuch wird eine InvalidCastException ausgelöst.

IConvertible.ToString(IFormatProvider)

Hiermit wird der Wert dieser Instanz unter Verwendung der angegebenen kulturabhängigen Formatierungsinformationen in eine entsprechende Zeichenfolge konvertiert.

IConvertible.ToType(Type, IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToUInt64(IFormatProvider).

IDecrementOperators<Char>.CheckedDecrement(Char)

Dekrementiert einen Wert.

IDecrementOperators<Char>.Decrement(Char)

Dekrementiert einen Wert.

IDivisionOperators<Char,Char,Char>.Division(Char, Char)

Dividiert einen Wert durch einen anderen, um den Quotienten zu berechnen.

IEqualityOperators<Char,Char,Boolean>.Equality(Char, Char)

Vergleicht zwei Werte, um die Gleichheit zu ermitteln.

IEqualityOperators<Char,Char,Boolean>.Inequality(Char, Char)

Vergleicht zwei Werte, um Ungleichheit zu ermitteln.

IFormattable.ToString(String, IFormatProvider)

Formatiert den Wert der aktuellen Instanz mit dem angegebenen Format.

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 Mindestwert des aktuellen Typs ab.

IModulusOperators<Char,Char,Char>.Modulus(Char, Char)

Teilt zwei Werte zusammen, um deren Modul oder Rest zu berechnen.

IMultiplicativeIdentity<Char,Char>.MultiplicativeIdentity

Ruft die multiplikative 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 das Absolute eines Werts.

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 Integralzahl 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 negativ unendlich ist.

INumberBase<Char>.IsNormal(Char)

Bestimmt, ob ein Wert normal ist.

INumberBase<Char>.IsOddInteger(Char)

Bestimmt, ob ein Wert eine ungerade Integralzahl darstellt.

INumberBase<Char>.IsPositive(Char)

Bestimmt, ob ein Wert positiv ist.

INumberBase<Char>.IsPositiveInfinity(Char)

Bestimmt, ob ein Wert positiv unendlich 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 0 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 die größere Größe aufweist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.

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 gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.

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 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 instance 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 instance des aktuellen Typs in einen anderen Typ zu konvertieren und dabei alle Werte zu überlasten, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.

INumberBase<Char>.TryConvertToTruncating<TOther>(Char, TOther)

Versucht, eine instance 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, der von einem bestimmten Betrag übrig bleibt.

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 des aktuellen instance in die angegebene 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 deren Differenz zu berechnen.

ISubtractionOperators<Char,Char,Char>.Subtraction(Char, Char)

Subtrahiert zwei Werte, um deren 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 Plus eines Werts.

IUtf8SpanFormattable.TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Versucht, den Wert des aktuellen instance als UTF-8 in die angegebene Bytesspanne zu formatieren.

Gilt für:

Threadsicherheit

Alle Member dieses Typs sind threadsicher. Elemente, die instance Zustand ändern, geben tatsächlich eine neue instance 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 instance dieses Typs enthält, durch eine Sperre geschützt werden, um die Threadsicherheit zu gewährleisten.

Weitere Informationen