Char Struktur

Definition

Stellt ein Zeichen als UTF-16-Codeeinheit dar.

public value class char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
public value class char : IComparable, IComparable<char>, IConvertible, IEquatable<char>, ISpanFormattable
public value class char : IComparable, IConvertible
public value class char : IComparable, IComparable<char>, IEquatable<char>
public struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
public struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>, ISpanFormattable
[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
[<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 IComparable, IConvertible
Public Structure Char
Implements IComparable, IComparable(Of Char), IEquatable(Of Char)
Vererbung
Attribute
Implementiert

Beispiele

Im folgenden Codebeispiel werden einige der Methoden in Char veranschaulicht.

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"
    }
}
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 zu darstellen. Der Wert eines Char -Objekts ist sein numerischer 16-Bit-Wert (Ordnungszahl).

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

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

Char-Objekte, Unicode-Zeichen und Zeichenfolgen

Ein String -Objekt ist eine sequenzielle Auflistung Char von -Strukturen, die eine Textzeichenfolge darstellt. Die meisten Unicode-Zeichen können durch ein einzelnes -Objekt dargestellt werden, aber ein Zeichen, das als Basiszeichen, Ersatzzeichenpaar und/oder kombinierende Zeichenfolge codiert ist, wird durch mehrere Char -Objekte Char dargestellt. Aus diesem Grund entspricht Char eine -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 zu darstellen:

  • Glyphen, die aus einem einzelnen Zeichen oder einem Basiszeichen gefolgt von einem oder mehreren kombinierenden Zeichen bestehen können. Das Zeichen ä wird beispielsweise durch ein -Objekt dargestellt, dessen Codeeinheit U+0061 ist, gefolgt von einem -Objekt, dessen Codeeinheit Char Char U+0308 ist. (Das Zeichen ä kann auch durch ein einzelnes Objekt definiert Char werden, das über eine Codeeinheit von U+00E4 verfügt.) Das folgende Beispiel veranschaulicht, dass das Zeichen ä aus zwei -Objekten Char 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:
    //       ä
    
    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 16 Ebenen zusätzlich zum BMP, das Ebene 0 darstellt. Ein Unicode-Codepunkt wird in UTF-32 durch einen 21-Bit-Wert dargestellt, der die Ebene enthält. U+1D160 stellt z. B. das ZEICHEN SYMBOL FÜR ACHTEN HINWEIS dar. Da die UTF-16-Codierung nur 16 Bits enthält, werden Zeichen außerhalb des BMP in UTF-16 durch Ersatzzeichenpaare dargestellt. Das folgende Beispiel veranschaulicht, dass U+D834 U+DD60 das UTF-32-Äquivalent von U+1D160 ist, das ZEICHEN SYMBOL 834 U+DD60. U+D834 ist das obere 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
    
    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 -Enumeration dargestellt und enthalten z. B. Werte wie UnicodeCategory UnicodeCategory.CurrencySymbol , und UnicodeCategory.LowercaseLetter UnicodeCategory.SpaceSeparator .

Um die Unicode-Kategorie eines Zeichens zu bestimmen, rufen Sie die GetUnicodeCategory -Methode auf. Das folgende Beispiel ruft beispielsweise auf, GetUnicodeCategory um die Unicode-Kategorie jedes Zeichens in einer Zeichenfolge anzuzeigen. Das Beispiel funktioniert nur ordnungsgemäß, wenn die -Instanz keine Ersatzzeichenpaare String auftrat.

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
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) von Unicode-Kategorien ab, die von der GetUnicodeCategory -Klasse gemeldet CharUnicodeInfo werden. Ab Version .NET Framework 4.6.2 werden Unicode-Zeichen basierend auf dem Unicode-Standard, Version 8.0.0, klassifiziert. In Versionen des .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 Objekte dargestellt werden kann, ist es nicht immer sinnvoll, Char mit einzelnen Objekten zu Char arbeiten. Im folgenden Beispiel werden beispielsweise die Unicode-Codepunkte, die die Zahlen 0 bis 9 darstellen, in UTF-16-codierte Codeeinheiten konvertiert. Da objekte fälschlicherweise Zeichen gleichgesetzt werden, wird fälschlicherweise berichtet, dass die resultierende Char 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.
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.

Gehen Sie wie folgt vor, um die Annahme zu vermeiden, dass Char ein -Objekt ein einzelnes Zeichen darstellt.

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

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

    int CountLetters(string s)
    {
        int letterCount = 0;
    
        foreach (Rune rune in s.EnumerateRunes())
        {
            if (Rune.IsLetter(rune))
            { letterCount++; }
        }
    
        return letterCount;
    }
    
  • Sie können die StringInfo -Klasse verwenden, um mit Textelementen anstelle einzelner Objekte zu Char arbeiten. Im folgenden Beispiel wird das -Objekt verwendet, um die Anzahl der Textelemente in einer Zeichenfolge zu zählen, die aus den Zahlen 0 bis StringInfo 9 besteht. Da ein Ersatzzeichenpaar als einzelnes Zeichen betrachtet wird, wird ordnungsgemäß berichtet, 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.
    
    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 enthält, das mindestens ein kombinierende Zeichen enthält, können Sie die -Methode aufrufen, um die Teilzeichenfolge in eine einzelne String.Normalize UTF-16-codierte Codeeinheit zu konvertieren. Im folgenden Beispiel wird die -Methode zum Konvertieren des Basiszeichens U+0061 (LATEINISCHER KLEINER BUCHSTABE A) und zum Kombinieren des Zeichens String.Normalize U+0308 (COMBINING DIAERESIS) in U+00E4 (LATEINISCHER KLEINER BUCHSTABE A MIT DIAERESIS) verwendet.

    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)
    
    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 -Struktur stellt Methoden zum Vergleichen von Objekten, Konvertieren des Werts des aktuellen Objekts in ein Objekt eines anderen Typs und Bestimmen der Char Char Char Unicode-Kategorie eines -Objekts Char zur Verfügung:

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 .
Die Unicode-Kategorie eines Zeichens GetUnicodeCategory

Siehe auch Rune.GetUnicodeCategory.
Bestimmen Sie, ob sich ein Zeichen in einer bestimmten Unicode-Kategorie befindet, z. B. Ziffer, Buchstabe, Interpunktion, Steuerzeichen und so weiter. IsControl, IsDigit IsHighSurrogate , , , , IsLetter , , , , , , IsLetterOrDigit , IsLower IsLowSurrogate IsNumber IsPunctuation IsSeparator IsSurrogate IsSurrogatePair IsSymbol IsUpper und IsWhiteSpace

Siehe auch entsprechende 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 Fall eines Char -Objekts ToLower, ToLowerInvariant, ToUpper und ToUpperInvariant

Siehe auch entsprechende Methoden für den Rune Typ.

Char-Werte und Interop

Wenn ein verwalteter 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 Char ANSI. Sie können das -Attribut auf Plattformaufrufdeklarationen und das -Attribut auf eine COM-Interopdeklaration anwenden, um zu steuern, welcher Zeichensatz von einem DllImportAttribute StructLayoutAttribute gemarshallten Char Typ verwendet wird.

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 true c zurück, wenn ein ASCII-Zeichen ist ([ U+0000..U+007F ]).

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

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 bereitgestellte Zeichenspanne zu formatieren.

Gilt für

Threadsicherheit

Alle Member dieses Typs sind threadsicher. Member, die den Instanzzustand 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 threadsicherheit zu gewährleisten.

Siehe auch