Char Struktur

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

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, 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>

[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>

[<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 IComparable, IConvertible

Public Structure Char
Implements IComparable, IComparable(Of Char), IEquatable(Of Char)

Vererbung

Object

ValueType

Char

Attribute

SerializableAttribute ComVisibleAttribute

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>

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

.NET verwendet die Char -Struktur, um Unicode-Codepunkte mithilfe der UTF-16-Codierung darzustellen. Der Wert eines Char Objekts ist sein 16-Bit-numerischer (Ordnungszahlwert).

Wenn Sie mit Unicode, Skalarwerten, Codepunkten, Ersatzzeichenpaaren, UTF-16 und dem Rune Typ nicht vertraut sind, lesen Sie Einführung in die Zeichencodierung in .NET.

In den folgenden Abschnitten wird die Beziehung zwischen einem Char Objekt und einem Zeichen untersucht und einige allgemeine Aufgaben erläutert, die mit Char Instanzen ausgeführt werden. Es wird empfohlen, dass Sie den Rune in .NET Core 3.0 eingeführten Typ als Alternative zu Char betrachten, um einige dieser Aufgaben auszuführen.

• Char-Objekte, Unicode-Zeichen und Zeichenfolgen
• Zeichen und Zeichenkategorien
• Zeichen und Textelemente
• Allgemeine Vorgänge
• Zeichenwerte und Interop

Char-Objekte, Unicode-Zeichen und Zeichenfolgen

Ein String -Objekt ist eine sequenzielle Auflistung von Char Strukturen, die eine Textzeichenfolge darstellt. Die meisten Unicode-Zeichen können durch ein einzelnes Char Objekt dargestellt werden, aber ein Zeichen, das als Basiszeichen, Ersatzzeichenpaar und/oder kombinationsbasierte Zeichenfolge codiert ist, wird durch mehrere Char Objekte dargestellt. Aus diesem Grund entspricht eine Char Struktur in einem String -Objekt nicht unbedingt einem einzelnen Unicode-Zeichen.

In den folgenden Fällen werden mehrere 16-Bit-Codeeinheiten verwendet, um einzelne Unicode-Zeichen darzustellen:

• Glyphen, die aus einem einzelnen Zeichen oder einem Basiszeichen gefolgt von einem oder mehreren kombinierten Zeichen bestehen können. Beispielsweise wird das Zeichen ä durch ein Char Objekt dargestellt, dessen Codeeinheit U+0061 ist, gefolgt von einem Char Objekt, dessen Codeeinheit U+0308 ist. (Das Zeichen ä kann auch durch ein einzelnes Char Objekt definiert werden, das über eine Codeeinheit von U+00E4 verfügt.) Das folgende Beispiel veranschaulicht, dass das Zeichen ä aus zwei Char -Objekten besteht.

  using System;
  using System.IO;
  
  public class Example
  {
     public static void Main()
     {
        StreamWriter sw = new StreamWriter("chars1.txt");
        char[] chars = { '\u0061', '\u0308' };
        string strng = new String(chars);
        sw.WriteLine(strng);
        sw.Close();
     }
  }
  // The example produces the following output:
  //       ä
  

  open System
  open System.IO
  
  let sw = new StreamWriter("chars1.txt")
  let chars = [| '\u0061'; '\u0308' |]
  let string = String chars
  sw.WriteLine string
  sw.Close()
  
  // The example produces the following output:
  //       ä
  

  Imports System.IO
  
  Module Example
     Public Sub Main()
        Dim sw As New StreamWriter("chars1.txt")
        Dim chars() As Char = { ChrW(&h0061), ChrW(&h0308) }
        Dim strng As New String(chars)
        sw.WriteLine(strng) 
        sw.Close()
     End Sub
  End Module
  ' The example produces the following output:
  '       ä
  

• Zeichen außerhalb der Unicode Basic Multilingual Plane (BMP). Unicode unterstützt zusätzlich zum BMP, der Ebene 0 darstellt, sechzehn Ebenen. Ein Unicode-Codepunkt wird in UTF-32 durch einen 21-Bit-Wert dargestellt, der die Ebene enthält. Beispielsweise stellt U+1D160 das ZEICHEN MUSICAL SYMBOL ACHTE NOTE dar. Da die UTF-16-Codierung nur 16 Bits aufweist, werden Zeichen außerhalb des BMP durch Ersatzzeichenpaare in UTF-16 dargestellt. Das folgende Beispiel veranschaulicht, dass das UTF-32-Äquivalent von U+1D160, dem ZEICHEN MUSICAL SYMBOL ACHTE NOTE, U+D834 U+DD60 ist. U+D834 ist das hohe Ersatzzeichen; Hohe Ersatzzeichen reichen von U+D800 bis U+DBFF. U+DD60 ist das niedrige Ersatzzeichen; Niedrige Ersatzzeichen reichen von U+DC00 bis U+DFFF.

  using System;
  using System.IO;
  
  public class Example
  {
     public static void Main()
     {
        StreamWriter sw = new StreamWriter(@".\chars2.txt");
        int utf32 = 0x1D160;
        string surrogate = Char.ConvertFromUtf32(utf32);
        sw.WriteLine("U+{0:X6} UTF-32 = {1} ({2}) UTF-16",
                     utf32, surrogate, ShowCodePoints(surrogate));
        sw.Close();
     }
  
     private static string ShowCodePoints(string value)
     {
        string retval = null;
        foreach (var ch in value)
           retval += String.Format("U+{0:X4} ", Convert.ToUInt16(ch));
  
        return retval.Trim();
     }
  }
  // The example produces the following output:
  //       U+01D160 UTF-32 = ð (U+D834 U+DD60) UTF-16
  

  open System
  open System.IO
  
  let showCodePoints (value: char seq) =
      let str =
          value
          |> Seq.map (fun ch -> $"U+{Convert.ToUInt16 ch:X4}")
          |> String.concat ""
      str.Trim()
  
  let sw = new StreamWriter(@".\chars2.txt")
  let utf32 = 0x1D160
  let surrogate = Char.ConvertFromUtf32 utf32
  sw.WriteLine $"U+{utf32:X6} UTF-32 = {surrogate} ({showCodePoints surrogate}) UTF-16"
  sw.Close()
  
  // The example produces the following output:
  //       U+01D160 UTF-32 = ð (U+D834 U+DD60) UTF-16
  

  Imports System.IO
  
  Module Example
     Public Sub Main()
        Dim sw As New StreamWriter(".\chars2.txt")
        Dim utf32 As Integer = &h1D160
        Dim surrogate As String = Char.ConvertFromUtf32(utf32)
        sw.WriteLine("U+{0:X6} UTF-32 = {1} ({2}) UTF-16", 
                     utf32, surrogate, ShowCodePoints(surrogate))
        sw.Close()                    
     End Sub
  
     Private Function ShowCodePoints(value As String) As String
        Dim retval As String = Nothing
        For Each ch In value
           retval += String.Format("U+{0:X4} ", Convert.ToUInt16(ch))
        Next
        Return retval.Trim()
     End Function
  End Module
  ' The example produces the following output:
  '       U+01D160 UTF-32 = ð (U+D834 U+DD60) UTF-16
  

Zeichen und Zeichenkategorien

Jedes Unicode-Zeichen oder gültige Ersatzzeichenpaar gehört zu einer Unicode-Kategorie. In .NET werden Unicode-Kategorien durch Member der UnicodeCategory -Enumeration dargestellt und enthalten z. B. Werte wie UnicodeCategory.CurrencySymbol, UnicodeCategory.LowercaseLetterund UnicodeCategory.SpaceSeparator.

Rufen Sie die -Methode auf, um die GetUnicodeCategory Unicode-Kategorie eines Zeichens zu bestimmen. Im folgenden Beispiel wird beispielsweise aufgerufen GetUnicodeCategory , um die Unicode-Kategorie jedes Zeichens in einer Zeichenfolge anzuzeigen. Das Beispiel funktioniert nur ordnungsgemäß, wenn in der String Instanz keine Ersatzzeichenpaare vorhanden sind.

using System;
using System.Globalization;

class Example
{
   public static void Main()
   {
      // Define a string with a variety of character categories.
      String s = "The red car drove down the long, narrow, secluded road.";
      // Determine the category of each character.
      foreach (var ch in s)
         Console.WriteLine("'{0}': {1}", ch, Char.GetUnicodeCategory(ch));
   }
}
// The example displays the following output:
//      'T': UppercaseLetter
//      'h': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'r': LowercaseLetter
//      'e': LowercaseLetter
//      'd': LowercaseLetter
//      ' ': SpaceSeparator
//      'c': LowercaseLetter
//      'a': LowercaseLetter
//      'r': LowercaseLetter
//      ' ': SpaceSeparator
//      'd': LowercaseLetter
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'v': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'd': LowercaseLetter
//      'o': LowercaseLetter
//      'w': LowercaseLetter
//      'n': LowercaseLetter
//      ' ': SpaceSeparator
//      't': LowercaseLetter
//      'h': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'l': LowercaseLetter
//      'o': LowercaseLetter
//      'n': LowercaseLetter
//      'g': LowercaseLetter
//      ',': OtherPunctuation
//      ' ': SpaceSeparator
//      'n': LowercaseLetter
//      'a': LowercaseLetter
//      'r': LowercaseLetter
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'w': LowercaseLetter
//      ',': OtherPunctuation
//      ' ': SpaceSeparator
//      's': LowercaseLetter
//      'e': LowercaseLetter
//      'c': LowercaseLetter
//      'l': LowercaseLetter
//      'u': LowercaseLetter
//      'd': LowercaseLetter
//      'e': LowercaseLetter
//      'd': LowercaseLetter
//      ' ': SpaceSeparator
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'a': LowercaseLetter
//      'd': LowercaseLetter
//      '.': OtherPunctuation

open System

// Define a string with a variety of character categories.
let s = "The red car drove down the long, narrow, secluded road."
// Determine the category of each character.
for ch in s do
    printfn $"'{ch}': {Char.GetUnicodeCategory ch}"

// The example displays the following output:
//      'T': UppercaseLetter
//      'h': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'r': LowercaseLetter
//      'e': LowercaseLetter
//      'd': LowercaseLetter
//      ' ': SpaceSeparator
//      'c': LowercaseLetter
//      'a': LowercaseLetter
//      'r': LowercaseLetter
//      ' ': SpaceSeparator
//      'd': LowercaseLetter
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'v': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'd': LowercaseLetter
//      'o': LowercaseLetter
//      'w': LowercaseLetter
//      'n': LowercaseLetter
//      ' ': SpaceSeparator
//      't': LowercaseLetter
//      'h': LowercaseLetter
//      'e': LowercaseLetter
//      ' ': SpaceSeparator
//      'l': LowercaseLetter
//      'o': LowercaseLetter
//      'n': LowercaseLetter
//      'g': LowercaseLetter
//      ',': OtherPunctuation
//      ' ': SpaceSeparator
//      'n': LowercaseLetter
//      'a': LowercaseLetter
//      'r': LowercaseLetter
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'w': LowercaseLetter
//      ',': OtherPunctuation
//      ' ': SpaceSeparator
//      's': LowercaseLetter
//      'e': LowercaseLetter
//      'c': LowercaseLetter
//      'l': LowercaseLetter
//      'u': LowercaseLetter
//      'd': LowercaseLetter
//      'e': LowercaseLetter
//      'd': LowercaseLetter
//      ' ': SpaceSeparator
//      'r': LowercaseLetter
//      'o': LowercaseLetter
//      'a': LowercaseLetter
//      'd': LowercaseLetter
//      '.': OtherPunctuation

Imports System.Globalization

Module Example
   Public Sub Main()
      ' Define a string with a variety of character categories.
      Dim s As String = "The car drove down the narrow, secluded road."
      ' Determine the category of each character.
      For Each ch In s
         Console.WriteLine("'{0}': {1}", ch, Char.GetUnicodeCategory(ch)) 
      Next
   End Sub
End Module
' The example displays the following output:
'       'T': UppercaseLetter
'       'h': LowercaseLetter
'       'e': LowercaseLetter
'       ' ': SpaceSeparator
'       'r': LowercaseLetter
'       'e': LowercaseLetter
'       'd': LowercaseLetter
'       ' ': SpaceSeparator
'       'c': LowercaseLetter
'       'a': LowercaseLetter
'       'r': LowercaseLetter
'       ' ': SpaceSeparator
'       'd': LowercaseLetter
'       'r': LowercaseLetter
'       'o': LowercaseLetter
'       'v': LowercaseLetter
'       'e': LowercaseLetter
'       ' ': SpaceSeparator
'       'd': LowercaseLetter
'       'o': LowercaseLetter
'       'w': LowercaseLetter
'       'n': LowercaseLetter
'       ' ': SpaceSeparator
'       't': LowercaseLetter
'       'h': LowercaseLetter
'       'e': LowercaseLetter
'       ' ': SpaceSeparator
'       'l': LowercaseLetter
'       'o': LowercaseLetter
'       'n': LowercaseLetter
'       'g': LowercaseLetter
'       ',': OtherPunctuation
'       ' ': SpaceSeparator
'       'n': LowercaseLetter
'       'a': LowercaseLetter
'       'r': LowercaseLetter
'       'r': LowercaseLetter
'       'o': LowercaseLetter
'       'w': LowercaseLetter
'       ',': OtherPunctuation
'       ' ': SpaceSeparator
'       's': LowercaseLetter
'       'e': LowercaseLetter
'       'c': LowercaseLetter
'       'l': LowercaseLetter
'       'u': LowercaseLetter
'       'd': LowercaseLetter
'       'e': LowercaseLetter
'       'd': LowercaseLetter
'       ' ': SpaceSeparator
'       'r': LowercaseLetter
'       'o': LowercaseLetter
'       'a': LowercaseLetter
'       'd': LowercaseLetter
'       '.': OtherPunctuation

Intern hängt die Methode für Zeichen außerhalb des ASCII-Bereichs (U+0000 bis U+00FF) GetUnicodeCategory von unicode-Kategorien ab, die von der CharUnicodeInfo -Klasse gemeldet werden. Ab .NET Framework 4.6.2 werden Unicode-Zeichen basierend auf dem Unicode-Standard, Version 8.0.0, klassifiziert. In Versionen der .NET Framework von .NET Framework 4 bis .NET Framework 4.6.1 werden sie basierend auf dem Unicode-Standard, Version 6.3.0, klassifiziert.

Zeichen und Textelemente

Da ein einzelnes Zeichen durch mehrere Char Objekte dargestellt werden kann, ist es nicht immer sinnvoll, mit einzelnen Char Objekten zu arbeiten. Im folgenden Beispiel werden beispielsweise die Unicode-Codepunkte, die die ägäischen Zahlen 0 bis 9 darstellen, in UTF-16-codierte Codeeinheiten konvertiert. Da objekte fälschlicherweise mit Zeichen gleichgesetzt Char werden, wird ungenau gemeldet, dass die resultierende Zeichenfolge 20 Zeichen enthält.

using System;

public class Example
{
   public static void Main()
   {
      string result = String.Empty;
      for (int ctr = 0x10107; ctr <= 0x10110; ctr++)  // Range of Aegean numbers.
         result += Char.ConvertFromUtf32(ctr);

      Console.WriteLine("The string contains {0} characters.", result.Length);
   }
}
// The example displays the following output:
//     The string contains 20 characters.

open System

let result =
    [ for i in 0x10107..0x10110 do  // Range of Aegean numbers.
        Char.ConvertFromUtf32 i ]
    |> String.concat ""

printfn $"The string contains {result.Length} characters."


// The example displays the following output:
//     The string contains 20 characters.

Module Example
   Public Sub Main()
      Dim result As String = String.Empty
      For ctr As Integer = &h10107 To &h10110     ' Range of Aegean numbers.
         result += Char.ConvertFromUtf32(ctr)
      Next         
      Console.WriteLine("The string contains {0} characters.", result.Length) 
   End Sub
End Module
' The example displays the following output:
'     The string contains 20 characters.

Sie können die folgenden Schritte ausführen, um die Annahme zu vermeiden, dass ein Char -Objekt ein einzelnes Zeichen darstellt:

• Sie können mit einem String Objekt in seiner Gesamtheit arbeiten, anstatt mit seinen einzelnen Zeichen zu arbeiten, um linguistischen Inhalt darzustellen und zu analysieren.

• Sie können wie im folgenden Beispiel gezeigt verwenden String.EnumerateRunes :

  int CountLetters(string s)
  {
      int letterCount = 0;
  
      foreach (Rune rune in s.EnumerateRunes())
      {
          if (Rune.IsLetter(rune))
          { letterCount++; }
      }
  
      return letterCount;
  }
  

  let countLetters (s: string) =
      let mutable letterCount = 0
  
      for rune in s.EnumerateRunes() do
          if Rune.IsLetter rune then
              letterCount <- letterCount + 1
  
      letterCount
  

• Sie können die StringInfo -Klasse verwenden, um mit Textelementen anstelle einzelner Char Objekte zu arbeiten. Im folgenden Beispiel wird das StringInfo -Objekt verwendet, um die Anzahl der Textelemente in einer Zeichenfolge zu zählen, die aus den ägäischen Zahlen 0 bis neun besteht. Da ein Ersatzzeichenpaar als einzelnes Zeichen betrachtet wird, wird ordnungsgemäß gemeldet, dass die Zeichenfolge zehn Zeichen enthält.

  using System;
  using System.Globalization;
  
  public class Example
  {
     public static void Main()
     {
        string result = String.Empty;
        for (int ctr = 0x10107; ctr <= 0x10110; ctr++)  // Range of Aegean numbers.
           result += Char.ConvertFromUtf32(ctr);
  
        StringInfo si = new StringInfo(result);
        Console.WriteLine("The string contains {0} characters.",
                          si.LengthInTextElements);
     }
  }
  // The example displays the following output:
  //       The string contains 10 characters.
  

  open System
  open System.Globalization
  
  let result =
      [ for i in 0x10107..0x10110 do  // Range of Aegean numbers.
          Char.ConvertFromUtf32 i ]
      |> String.concat ""
  
  
  let si = StringInfo result
  printfn $"The string contains {si.LengthInTextElements} characters."
  
  // The example displays the following output:
  //       The string contains 10 characters.
  

  Imports System.Globalization
  
  Module Example
     Public Sub Main()
        Dim result As String = String.Empty
        For ctr As Integer = &h10107 To &h10110     ' Range of Aegean numbers.
           result += Char.ConvertFromUtf32(ctr)
        Next         
        Dim si As New StringInfo(result)
        Console.WriteLine("The string contains {0} characters.", si.LengthInTextElements) 
     End Sub
  End Module
  ' The example displays the following output:
  '       The string contains 10 characters.
  

• Wenn eine Zeichenfolge ein Basiszeichen mit einem oder mehreren kombinierten Zeichen enthält, können Sie die String.Normalize -Methode aufrufen, um die Teilzeichenfolge in eine einzelne UTF-16-codierte Codeeinheit zu konvertieren. Im folgenden Beispiel wird die String.Normalize -Methode aufgerufen, um das Basiszeichen U+0061 (LATIN SMALL LETTER A) zu konvertieren und das Zeichen U+0308 (COMBINING DIAERESIS) in U+00E4 (LATIN SMALL LETTER A WITH DIAERESIS) zu kombinieren.

  using System;
  
  public class Example
  {
     public static void Main()
     {
        string combining = "\u0061\u0308";
        ShowString(combining);
  
        string normalized = combining.Normalize();
        ShowString(normalized);
     }
  
     private static void ShowString(string s)
     {
        Console.Write("Length of string: {0} (", s.Length);
        for (int ctr = 0; ctr < s.Length; ctr++) {
           Console.Write("U+{0:X4}", Convert.ToUInt16(s[ctr]));
           if (ctr != s.Length - 1) Console.Write(" ");
        }
        Console.WriteLine(")\n");
     }
  }
  // The example displays the following output:
  //       Length of string: 2 (U+0061 U+0308)
  //
  //       Length of string: 1 (U+00E4)
  

  open System
  
  let showString (s: string) =
      printf $"Length of string: {s.Length} ("
      for i = 0 to s.Length - 1 do
          printf $"U+{Convert.ToUInt16 s[i]:X4}"
          if i <> s.Length - 1 then printf " "
      printfn ")\n"
  
  let combining = "\u0061\u0308"
  showString combining
  
  let normalized = combining.Normalize()
  showString normalized
  
  // The example displays the following output:
  //       Length of string: 2 (U+0061 U+0308)
  //
  //       Length of string: 1 (U+00E4)
  

  Module Example
     Public Sub Main()
        Dim combining As String = ChrW(&h0061) + ChrW(&h0308)
        ShowString(combining)
        
        Dim normalized As String = combining.Normalize()
        ShowString(normalized)
     End Sub
     
     Private Sub ShowString(s As String)
        Console.Write("Length of string: {0} (", s.Length)
        For ctr As Integer = 0 To s.Length - 1
           Console.Write("U+{0:X4}", Convert.ToUInt16(s(ctr)))
           If ctr <> s.Length - 1 Then Console.Write(" ")
        Next 
        Console.WriteLine(")")
        Console.WriteLine()
     End Sub
  End Module
  ' The example displays the following output:
  '       Length of string: 2 (U+0061 U+0308)
  '       
  '       Length of string: 1 (U+00E4)
  

Allgemeine Vorgänge

Die Char -Struktur stellt Methoden bereit, um Objekte zu vergleichen Char , den Wert des aktuellen Char Objekts in ein Objekt eines anderen Typs zu konvertieren und die Unicode-Kategorie eines Char Objekts zu bestimmen:

Aufgabe	Verwenden Sie diese System.Char Methoden
Vergleichen von Char Objekten	CompareTo und Equals
Konvertieren eines Codepunkts in eine Zeichenfolge	ConvertFromUtf32 Siehe auch den Rune Typ.
Konvertieren eines Char Objekts oder eines Ersatzzeichenpaars von Char Objekten in einen Codepunkt	Für ein einzelnes Zeichen: Convert.ToInt32(Char) Für ein Ersatzzeichenpaar oder ein Zeichen in einer Zeichenfolge: Char.ConvertToUtf32 Siehe auch den Rune Typ.
Abrufen der Unicode-Kategorie eines Zeichens	GetUnicodeCategory Siehe auch Rune.GetUnicodeCategory.
Bestimmen, ob sich ein Zeichen in einer bestimmten Unicode-Kategorie befindet, z. B. Ziffer, Buchstabe, Interpunktion, Steuerelementzeichen usw.	IsControl, IsDigit, IsHighSurrogate, IsLetterIsLetterOrDigit, IsLower, IsLowSurrogate, , IsNumber, IsPunctuation, IsSeparator, IsSurrogate, IsSurrogatePairIsSymbolIsUpperundIsWhiteSpace Siehe auch die entsprechenden Methoden für den Rune Typ.
Konvertieren eines Char Objekts, das eine Zahl darstellt, in einen numerischen Werttyp	GetNumericValue Siehe auch Rune.GetNumericValue.
Konvertieren eines Zeichens in einer Zeichenfolge in ein Char Objekt	Parse und TryParse
Konvertieren eines Char Objekts in ein String Objekt	ToString
Ändern der Groß-/Kleinschreibung eines Char Objekts	ToLower, ToLowerInvariant, ToUpper und ToUpperInvariant Siehe auch die entsprechenden Methoden für den Rune Typ.

Zeichenwerte und Interop

Wenn ein verwalteter Char Typ, der als Unicode-UTF-16-codierte Codeeinheit dargestellt wird, an nicht verwalteten Code übergeben wird, konvertiert der Interop-Marshaller den Zeichensatz standardmäßig in ANSI. Sie können das DllImportAttribute -Attribut auf Plattformaufrufdeklarationen und das StructLayoutAttribute -Attribut auf eine COM-Interopdeklaration anwenden, um zu steuern, welchen Zeichensatz ein gemarshallter Char Typ verwendet.

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 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 ASCII-Hexademieziffer kategorisiert wird.
IsAsciiHexDigitLower(Char)	Gibt an, ob ein Zeichen als hexademische Ziffer in ASCII-Kleinbuchstaben kategorisiert wird.
IsAsciiHexDigitUpper(Char)	Gibt an, ob ein Zeichen als ASCII-Hexademieziffer in Großbuchstaben kategorisiert wird.
IsAsciiLetter(Char)	Gibt an, ob ein Zeichen als ASCII-Buchstabe kategorisiert wird.
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 ein Zeichen innerhalb des angegebenen inklusiven Bereichs liegt.
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

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 komplementen Darstellung des aktuellen Werts in Bits ab.
IBinaryInteger<Char>.TryWriteBigEndian(Span<Byte>, Int32)	Versucht, den aktuellen Wert im Big-Endian-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.
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.
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).
IFormattable.ToString(String, IFormatProvider)	Formatiert den Wert der aktuellen Instanz mit dem angegebenen Format.
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Versucht, den Wert der aktuellen Instanz in die angegebene Zeichenspanne zu formatieren.

Threadsicherheit

Alle Member dieses Typs sind threadsicher. Member, die den Instanzstatus zu ändern scheinen, 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.

Siehe auch

• IComparable
• IConvertible
• String