Char-Struktur

Stellt ein Unicode-Zeichen dar.

Namespace: System
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
<SerializableAttribute> _
<ComVisibleAttribute(True)> _
Public Structure Char
    Implements IComparable, IConvertible, IComparable(Of Char), _
    IEquatable(Of Char)
'Usage
Dim instance As Char

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
public struct Char : IComparable, IConvertible, IComparable<char>, 
    IEquatable<char>

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
public value class Char : IComparable, IConvertible, IComparable<wchar_t>, 
    IEquatable<wchar_t>

/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
public final class Char extends ValueType implements IComparable, IConvertible, 
    IComparable<char>, IEquatable<char>

JScript unterstützt die Verwendung von Strukturen, aber nicht die Deklaration von neuen Strukturen.

Hinweise

.NET Framework verwendet die Char-Struktur, um Unicode-Zeichen darzustellen. Im Unicode-Standard werden alle Unicode-Zeichen mit einer eindeutigen 21-Bit-Skalarzahl bezeichnet, die Codepunkt genannt wird, und die UTF-16-Codierungsform definiert, die angibt, wie ein Codepunkt in einer Folge eines oder mehrerer 16-Bit-Werte codiert werden. Jeder 16-Bit-Wert liegt zwischen hexadezimal 0x0000 und hexadezimal 0xFFFF und wird in einer Char-Struktur gespeichert. Der Wert eines Char-Objekts ist sein numerischer (ordinaler) 16-Bit-Wert.

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 als Basiszeichen, Ersatzzeichenpaar und oder Kombinationszeichenfolge codiertes Zeichen wird durch mehrere Char-Objekte dargestellt. Daher ist eine Char-Struktur in einem String-Objekt nicht notwendigerweise gleich einem einzelnen Unicode-Zeichen.

Weitere Informationen zum Unicode-Standard finden Sie auf der Unicode-Homepage (nur auf Englisch verfügbar).

Funktionalität

Die Char-Struktur stellt Methoden zum Vergleichen von Char-Objekten, zum Konvertieren des Werts des aktuellen Char-Objekts in ein Objekt eines anderen Typs und zum Bestimmen der Unicode-Kategorie eines Char-Objekts bereit:

• Verwenden Sie die CompareTo-Methode und die Equals-Methode, um Char-Objekte zu vergleichen.

• Verwenden Sie die ConvertFromUtf32-Methode, um einen Codepunkt in eine Zeichenfolge zu konvertieren. Verwenden Sie die ConvertToUtf32-Methoden, um ein Char-Objekt oder ein Ersatzzeichenpaar aus Char-Objekten in einen Codepunkt zu konvertieren.

• Mit den GetUnicodeCategory-Methoden können Sie die Unicode-Kategorie eines Zeichens abrufen. Verwenden Sie die Methoden IsControl, IsDigit, IsHighSurrogate, IsLetter, IsLetterOrDigit, IsLower, IsLowSurrogate, IsNumber, IsPunctuation, IsSeparator, IsSurrogate, IsSurrogatePair, IsSymbol, IsUpper und IsWhiteSpace, um zu bestimmen, ob ein Zeichen sich in einer bestimmten Unicode-Kategorie wie Ziffer, Buchstabe, Satzzeichen, Steuerzeichen usw. befindet.

• Verwenden Sie die GetNumericValue-Methoden, um ein Char-Objekt, das eine Zahl darstellt, in einen numerischen Werttyp darzustellen. Verwenden Sie Parse und TryParse, um ein Zeichen in einer Zeichenfolge in ein Char-Objekt zu konvertieren. Verwenden Sie ToString, um ein Char-Objekt in ein String-Objekt zu konvertieren.

• Verwenden Sie die Methoden ToLower, ToLowerInvariant, ToUpper und ToUpperInvariant, um die Groß- und Kleinschreibung eines Char-Objekts zu ändern.

Schnittstellenimplementierungen

Dieser Typ implementiert die Schnittstellen IConvertible, IComparable und IComparable. Verwenden Sie für Konvertierungen die Convert-Klasse anstelle der expliziten Implementierung der Schnittstellenmember von IConvertible für diesen Typ.

Beispiel

Im folgenden Codebeispiel werden einige der Methoden in Char veranschaulicht.

imports System

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

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"
    }
}

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"
}

import System.* ;

public class CharStructureSample
{
    public static void main(String[] args)
    {
        Character chA = new Character('A');
        char ch1 = '1';
        String str = "test string";

        // Output: "-1" (meaning 'A' is 1 less than 'B')        
        Console.WriteLine(chA.compareTo(new Character('B')));        
        // Output: "True"
        Console.WriteLine(chA.equals(new Character('A')));            
        // Output: "1"
        Console.WriteLine(System.Char.GetNumericValue(ch1));        
        // Output: "True"
        Console.WriteLine(Char.IsControl('\t'));                    
        // Output: "True"
        Console.WriteLine(System.Char.IsDigit(ch1));                
        // Output: "False"
        Console.WriteLine(Char.IsLetter(','));                        
        // Output: "True"
        Console.WriteLine(Char.IsLower('u'));                        
        // Output: "True"
        Console.WriteLine(System.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: "S"
        Console.WriteLine(Char.Parse("S"));                            
        // Output: "m"
        Console.WriteLine(Char.ToLower('M'));                        
        // Output: "x"
        Console.WriteLine(System.Convert.ToString('x'));                
    } //main
} //CharStructureSample

Threadsicherheit

Dieser Typ ist sicher bei Multithreadoperationen.

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0

Siehe auch

Referenz

Char-Member
System-Namespace
IComparable
IConvertible
String