Char Struktur

Definition

Namespace:

System

Assembly:

System.Runtime.dll

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

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

Wenn Sie nicht mit Unicode, skalaren Werten, Codepunkten, Ersatzpaaren, UTF-16 und dem Rune Typ vertraut sind, finden Sie weitere Informationen unter Einführung in die Zeichencodierung in .NET.

In den folgenden Abschnitten wird die Beziehung zwischen einem Char Objekt und einem Zeichen untersucht, und es werden einige allgemeine Aufgaben erläutert, die mit Char Instanzen ausgeführt werden. Es wird empfohlen, den Rune in .NET Core 3.0 eingeführten Typ als Alternative für einige dieser Aufgaben in Betracht zu Char ziehen.

• Char-Objekte, Unicode-Zeichen und Zeichenfolgen
• Zeichen und Zeichenkategorien
• Zeichen und Textelemente
• Allgemeine Vorgänge
• Char-Werte 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, Ersatzpaar und/oder kombinierte Zeichenfolge codiert ist, wird durch mehrere Char Objekte dargestellt. Aus diesem Grund ist eine Char Struktur in einem String Objekt nicht notwendigerweise gleichbedeutend mit 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 Kombinationszeichen bestehen können. Das Zeichen ä wird beispielsweise 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 sechzehn Ebenen zusätzlich zum BMP, der Ebene 0 darstellt. Ein Unicode-Codepunkt wird in UTF-32 durch einen 21-Bit-Wert dargestellt, der die Ebene enthält. U+1D160 stellt beispielsweise 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 keine Ersatzzeichenpaare im String instance 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 auf Der 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. Für instance werden im folgenden Beispiel 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

IAdditionOperators<Char,Char,Char>.Addition(Char, Char)	Fügt zwei Werte zusammen, um deren Summe zu berechnen.
IAdditionOperators<Char,Char,Char>.CheckedAddition(Char, Char)	Fügt zwei Werte zusammen, um deren 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 komplementen Darstellung 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 nach links um einen bestimmten Betrag.
IBinaryInteger<Char>.RotateRight(Char, Int32)	Rotiert einen Wert um einen bestimmten Betrag nach rechts.
IBinaryInteger<Char>.TrailingZeroCount(Char)	Berechnet die Anzahl der nachfolgenden 0 Bits 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-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.
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.
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.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.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 bereitgestellte Bytespanne zu formatieren.

Threadsicherheit

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

• IComparable
• IConvertible
• String