Char 結構

  • 參考

定義

命名空間:
System
組件:
System.Runtime.dll
組件:
mscorlib.dll
組件:
netstandard.dll

將字元表示為 UTF-16 程式碼單位。

public value class char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
public value class char : IComparable, IComparable<char>, IConvertible, IEquatable<char>, ISpanFormattable
public value class char : IComparable<char>, IConvertible, IEquatable<char>, IParsable<char>, ISpanParsable<char>, System::Numerics::IAdditionOperators<char, char, char>, System::Numerics::IAdditiveIdentity<char, char>, System::Numerics::IBinaryInteger<char>, System::Numerics::IBinaryNumber<char>, System::Numerics::IBitwiseOperators<char, char, char>, System::Numerics::IComparisonOperators<char, char, bool>, System::Numerics::IDecrementOperators<char>, System::Numerics::IDivisionOperators<char, char, char>, System::Numerics::IEqualityOperators<char, char, bool>, System::Numerics::IIncrementOperators<char>, System::Numerics::IMinMaxValue<char>, System::Numerics::IModulusOperators<char, char, char>, System::Numerics::IMultiplicativeIdentity<char, char>, System::Numerics::IMultiplyOperators<char, char, char>, System::Numerics::INumber<char>, System::Numerics::INumberBase<char>, System::Numerics::IShiftOperators<char, int, char>, System::Numerics::ISubtractionOperators<char, char, char>, System::Numerics::IUnaryNegationOperators<char, char>, System::Numerics::IUnaryPlusOperators<char, char>, System::Numerics::IUnsignedNumber<char>
public value class char : IComparable, IConvertible
public value class char : IComparable, IComparable<char>, IEquatable<char>
public struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
public readonly struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
public readonly struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>, ISpanFormattable
public readonly struct Char : IComparable<char>, IConvertible, IEquatable<char>, IParsable<char>, ISpanParsable<char>, System.Numerics.IAdditionOperators<char,char,char>, System.Numerics.IAdditiveIdentity<char,char>, System.Numerics.IBinaryInteger<char>, System.Numerics.IBinaryNumber<char>, System.Numerics.IBitwiseOperators<char,char,char>, System.Numerics.IComparisonOperators<char,char,bool>, System.Numerics.IDecrementOperators<char>, System.Numerics.IDivisionOperators<char,char,char>, System.Numerics.IEqualityOperators<char,char,bool>, System.Numerics.IIncrementOperators<char>, System.Numerics.IMinMaxValue<char>, System.Numerics.IModulusOperators<char,char,char>, System.Numerics.IMultiplicativeIdentity<char,char>, System.Numerics.IMultiplyOperators<char,char,char>, System.Numerics.INumber<char>, System.Numerics.INumberBase<char>, System.Numerics.IShiftOperators<char,int,char>, System.Numerics.ISubtractionOperators<char,char,char>, System.Numerics.IUnaryNegationOperators<char,char>, System.Numerics.IUnaryPlusOperators<char,char>, System.Numerics.IUnsignedNumber<char>
[System.Serializable]
public struct Char : IComparable, IConvertible
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
public struct Char : IComparable, IComparable<char>, IEquatable<char>
type char = struct
    interface IConvertible
type char = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable
type char = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<char>
    interface ISpanFormattable
    interface ISpanParsable<char>
    interface IAdditionOperators<char, char, char>
    interface IAdditiveIdentity<char, char>
    interface IBinaryInteger<char>
    interface IBinaryNumber<char>
    interface IBitwiseOperators<char, char, char>
    interface IComparisonOperators<char, char, bool>
    interface IEqualityOperators<char, char, bool>
    interface IDecrementOperators<char>
    interface IDivisionOperators<char, char, char>
    interface IIncrementOperators<char>
    interface IModulusOperators<char, char, char>
    interface IMultiplicativeIdentity<char, char>
    interface IMultiplyOperators<char, char, char>
    interface INumber<char>
    interface INumberBase<char>
    interface ISubtractionOperators<char, char, char>
    interface IUnaryNegationOperators<char, char>
    interface IUnaryPlusOperators<char, char>
    interface IShiftOperators<char, int, char>
    interface IMinMaxValue<char>
    interface IUnsignedNumber<char>
[<System.Serializable>]
type char = struct
    interface IConvertible
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type char = struct
    interface IConvertible
type char = struct
Public Structure Char
Implements IComparable, IComparable(Of Char), IConvertible, IEquatable(Of Char)
Public Structure Char
Implements IComparable, IComparable(Of Char), IConvertible, IEquatable(Of Char), ISpanFormattable
Public Structure Char
Implements IAdditionOperators(Of Char, Char, Char), IAdditiveIdentity(Of Char, Char), IBinaryInteger(Of Char), IBinaryNumber(Of Char), IBitwiseOperators(Of Char, Char, Char), IComparable(Of Char), IComparisonOperators(Of Char, Char, Boolean), IConvertible, IDecrementOperators(Of Char), IDivisionOperators(Of Char, Char, Char), IEqualityOperators(Of Char, Char, Boolean), IEquatable(Of Char), IIncrementOperators(Of Char), IMinMaxValue(Of Char), IModulusOperators(Of Char, Char, Char), IMultiplicativeIdentity(Of Char, Char), IMultiplyOperators(Of Char, Char, Char), INumber(Of Char), INumberBase(Of Char), IParsable(Of Char), IShiftOperators(Of Char, Integer, Char), ISpanParsable(Of Char), ISubtractionOperators(Of Char, Char, Char), IUnaryNegationOperators(Of Char, Char), IUnaryPlusOperators(Of Char, Char), IUnsignedNumber(Of Char)
Public Structure Char
Implements IComparable, IConvertible
Public Structure Char
Implements IComparable, IComparable(Of Char), IEquatable(Of Char)
繼承
Object
ValueType
Char
屬性
SerializableAttribute ComVisibleAttribute
實作
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>

範例

下列程式碼範例示範 中的 Char 一些方法。

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

備註

.NET 會 Char 使用 結構，使用 UTF-16 編碼來表示 Unicode 字碼點。 物件的值為 Char 它的 16 位數值 (序數) 值。

如果您不熟悉 Unicode、純量值、字碼點、代理字組、UTF-16 和 Rune 類型，請參閱 .NET 中的字元編碼簡介。

下列各節會檢查 物件與字元之間的 Char 關聯性，並討論使用 Char 實例執行的一些常見工作。 建議您考慮在 Rune .NET Core 3.0 中引進的類型，作為執行其中一些工作的替代方案 Char 。

Char 物件、Unicode 字元和字串

String物件是結構的循序集合 Char ，代表文字字串。 大部分 Unicode 字元都可以由單 Char 一物件表示，但編碼為基底字元、Surrogate 字組和/或結合字元序列的字元是由多個 Char 物件表示。 因此， Char 物件中的 String 結構不一定等於單一 Unicode 字元。

在下列情況下，會使用多個 16 位程式碼單位來代表單一 Unicode 字元：

  • 字元，其可能包含單一字元或基底字元，後面接著一或多個結合字元。 例如，字元 ä 是由 Char 程式碼單位為 U+0061，後面接著 Char 程式碼單位為 U+0308 的物件來表示。 (字元 ä 也可以由具有 U+00E4.) 程式碼單位的單 Char 一物件定義。下列範例說明字元 ä 是由兩 Char 個 物件所組成。

    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:
'       ä

  • Unicode 基本多語平面以外的字元 (BMP) 。 除了代表平面 0 的 BMP 之外，Unicode 還支援十六個平面。 Unicode 字碼指標是以 UTF-32 表示的 21 位值，其中包含平面。 例如，U+1D160 代表[符號第八個記事] 字元。 因為 UTF-16 編碼只有 16 位，所以 BMP 以外的字元會以 UTF-16 中的 Surrogate 字組表示。 下列範例說明 UTF-32 相當於 U+1D160 的 U+1D160 是 U+D834 U+DD60。 U+D834 是高 Surrogate;高代理範圍從 U+D800 到 U+DBFF。 U+DD60 是低 Surrogate;低代理範圍從 U+DC00 到 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

字元和字元類別

每個 Unicode 字元或有效的 Surrogate 字組都屬於 Unicode 類別。 在 .NET 中，Unicode 類別是由列舉的成員表示， UnicodeCategory 並包含例如 、 UnicodeCategory.LowercaseLetter 和 UnicodeCategory.SpaceSeparator 等 UnicodeCategory.CurrencySymbol 值。

若要判斷字元的 Unicode 類別，請呼叫 GetUnicodeCategory 方法。 例如，下列範例會呼叫 來 GetUnicodeCategory 顯示字串中每個字元的 Unicode 類別。 只有在 實例中 String 沒有 Surrogate 配對時，此範例才能正確運作。

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

就內部而言，對於 ASCII 範圍以外的字元， (U+0000 到 U+00FF) ， GetUnicodeCategory 此方法取決於 類別所 CharUnicodeInfo 報告的 Unicode 類別。 從 .NET Framework 4.6.2 開始，Unicode 字元會根據Unicode Standard 8.0.0 版進行分類。 在從 .NET Framework 4 到 .NET Framework 4.6.1 .NET Framework 版本中，會根據Unicode Standard 6.3.0版分類。

字元和文字元素

因為單一字元可以由多個 Char 物件表示，所以使用個別 Char 物件並不一定有意義。 例如，下列範例會將代表[內嵌數位零到 9] 的 Unicode 字碼指標轉換為 UTF-16 編碼的程式碼單位。 因為其錯誤地將物件與字元相等 Char ，所以它不正確地報告產生的字串有 20 個字元。

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.

您可以執行下列動作，以避免假設 Char 物件代表單一字元：

  • 您可以完全使用 String 物件，而不是使用其個別字元來表示和分析語言內容。

  • 您可以使用 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

  • 您可以使用 類別 StringInfo 來處理文字元素，而不是個別 Char 物件。 下列範例會 StringInfo 使用 物件來計算字串中的文字元素數目，此字串包含零到 9 個數字。 因為它會將 Surrogate 配對視為單一字元，所以它會正確報告字串包含十個字元。

    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.

  • 如果字串包含具有一或多個組合字元的基底字元，您可以呼叫 String.Normalize 方法，將子字串轉換成單一 UTF-16 編碼的程式碼單位。 下列範例會呼叫 String.Normalize 方法，將基底字元 U+0061 (LATIN SMALL LETTER A) ，並將字元 U+0308 (COMBINING DIAERESIS) 合併為 U+00E4 (LATIN SMALL LETTER A WITH DIAERESIS) 。

    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)

常見作業

結構 Char 提供比較 Char 物件的方法、將目前 Char 物件的值轉換成另一 Char 種類型的物件，並判斷物件的 Unicode 類別：

作法 System.Char使用這些方法
比較 Char 物件 CompareTo 和 Equals
將程式碼點轉換為字串 ConvertFromUtf32

另 Rune 請參閱類型。
將 Char 物件或代理配對 Char 物件轉換成字碼點 針對單一字元： Convert.ToInt32(Char)

針對代理字組或字串中的字元： Char.ConvertToUtf32

另 Rune 請參閱類型。
取得字元的 Unicode 類別 GetUnicodeCategory

另請參閱 Rune.GetUnicodeCategory。
判斷字元是否在特定 Unicode 類別中，例如數位、字母、標點符號、控制字元等等 IsControl、 IsDigit 、 IsHighSurrogate 、 IsLetter 、、、 IsLowSurrogateIsPunctuationIsSurrogateIsSeparatorIsSurrogatePairIsLowerIsNumberIsLetterOrDigit 、 和 IsSymbolIsUpperIsWhiteSpace

另請參閱型別上的 Rune 對應方法。
Char將代表數位的 物件轉換成數數值型別 GetNumericValue

另請參閱 Rune.GetNumericValue。
將字串中的字元轉換成 Char 物件 Parse 和 TryParse
將 Char 物件轉換成 String 物件 ToString
變更 物件的大小寫 Char ToLower、ToLowerInvariant、ToUpper 和 ToUpperInvariant

另請參閱型別上的 Rune 對應方法。

Char 值和 Interop

當 Managed Char 類型表示為 Unicode UTF-16 編碼程式碼單位時，會傳遞至 Unmanaged 程式碼，Interop 封送處理器預設會將字元集轉換為 ANSI。 您可以將 屬性套用至平台叫用宣告，並將 StructLayoutAttribute 屬性套用 DllImportAttribute 至 COM Interop 宣告，以控制封送處理 Char 類型所使用的字元集。

欄位

MaxValue

表示 Char 最大的可能值。 這個欄位為常數。
MinValue

表示 Char 最小的可能值。 這個欄位為常數。

方法

CompareTo(Char)

比較這個執行個體與指定的 Char 物件，並且表示這個執行個體在排序次序中，位於所指定 Char 物件之前、之後或相同位置。
CompareTo(Object)

比較這個執行個體與指定的物件，並且表示這個執行個體在排序次序中，位於所指定 Object 之前、之後或相同位置。
ConvertFromUtf32(Int32)

將指定之 Unicode 字碼指標轉換成 UTF-16 編碼的字串。
ConvertToUtf32(Char, Char)

將 UTF-16 編碼之 Surrogate 字組的值轉換成 Unicode 字碼指標。
ConvertToUtf32(String, Int32)

將字串中指定之位置上的 UTF-16 編碼之字元或 Surrogate 字組的值轉換成 Unicode 字碼指標。
Equals(Char)

傳回值，表示這個執行個體是否等於指定的 Char 物件。
Equals(Object)

傳回值，這個值指出此執行個體是否與指定的物件相等。
GetHashCode()

傳回這個執行個體的雜湊碼。
GetNumericValue(Char)

將指定的數字 Unicode 字元轉換成雙精確度浮點數。
GetNumericValue(String, Int32)

將指定字串中指定位置的數字 Unicode 字元轉換成雙精確度浮點數。
GetTypeCode()

傳回實值類型 TypeCode 的 Char。
GetUnicodeCategory(Char)

將指定的 Unicode 字元分類至由其中一個 UnicodeCategory 值所識別的群組。
GetUnicodeCategory(String, Int32)

將指定字串中指定位置處的字元，分類至由其中一個 UnicodeCategory 值所識別的群組。
IsAscii(Char)

true如果 c 是 ASCII 字元 ([ U+0000..U+007F ]) ，則傳回 。
IsAsciiDigit(Char)

指出字元是否分類為 ASCII 數位。
IsAsciiHexDigit(Char)

指出字元是否分類為 ASCII 十六進位數位。
IsAsciiHexDigitLower(Char)

指出字元是否分類為 ASCII 小寫十六進位數位。
IsAsciiHexDigitUpper(Char)

指出字元是否分類為 ASCII 大寫十六進位數位。
IsAsciiLetter(Char)

指出字元是否分類為 ASCII 字母。
IsAsciiLetterLower(Char)

指出字元是否分類為小寫 ASCII 字母。
IsAsciiLetterOrDigit(Char)

指出字元是否分類為 ASCII 字母或數位。
IsAsciiLetterUpper(Char)

指出字元是否分類為大寫 ASCII 字母。
IsBetween(Char, Char, Char)

指出字元是否在指定的內含範圍內。
IsControl(Char)

指示指定的 Unicode 字元是否分類為控制字元。
IsControl(String, Int32)

指示指定的字串中指定位置處的字元是否分類為控制字元。
IsDigit(Char)

指示指定的 Unicode 字元是否分類為十進位數字。
IsDigit(String, Int32)

指示指定的字串中指定位置處的字元是否分類為十進位數字。
IsHighSurrogate(Char)

指出指定的 Char 物件是否為高 Surrogate。
IsHighSurrogate(String, Int32)

表示字串中指定位置處的 Char 物件是否為高 Surrogate。
IsLetter(Char)

表示指定的 Unicode 字元是否分類為 Unicode 字母。
IsLetter(String, Int32)

指示指定的字串中指定位置處的字元是否分類為 Unicode 字母。
IsLetterOrDigit(Char)

指示指定的 Unicode 字元是否分類為字母或十進位數字。
IsLetterOrDigit(String, Int32)

指示指定的字串中指定位置處的字元是否分類為字母或十進位數字。
IsLower(Char)

指示指定的 Unicode 字元是否分類為小寫字母。
IsLower(String, Int32)

指示指定的字串中指定位置處的字元是否分類為小寫字母。
IsLowSurrogate(Char)

指出指定的 Char 物件是否為低 Surrogate。
IsLowSurrogate(String, Int32)

表示字串中指定位置處的 Char 物件是否為低 Surrogate。
IsNumber(Char)

指示指定的 Unicode 字元是否分類為數字。
IsNumber(String, Int32)

指示指定的字串中指定位置處的字元是否分類為數字。
IsPunctuation(Char)

指示指定的 Unicode 字元是否分類為標點符號。
IsPunctuation(String, Int32)

指示指定的字串中指定位置處的字元是否分類為標點符號。
IsSeparator(Char)

指示指定的 Unicode 字元是否分類為分隔符號字元。
IsSeparator(String, Int32)

指示指定的字串中指定位置處的字元是否分類為分隔符號字元。
IsSurrogate(Char)

指出指定的字元是否有 Surrogate 字碼單位。
IsSurrogate(String, Int32)

指出位於指定的字串中指定位置處的字元是否有 Surrogate 字碼單位。
IsSurrogatePair(Char, Char)

表示兩個指定的 Char 物件是否組成 Surrogate 字組。
IsSurrogatePair(String, Int32)

表示字串中指定位置處的兩個相鄰 Char 物件是否組成 Surrogate 字組。
IsSymbol(Char)

指示指定的 Unicode 字元是否分類為符號字元。
IsSymbol(String, Int32)

指示指定的字串中指定位置處的字元是否分類為符號字元。
IsUpper(Char)

指示指定的 Unicode 字元是否分類為大寫字母。
IsUpper(String, Int32)

指示指定的字串中指定位置處的字元是否分類為大寫字母。
IsWhiteSpace(Char)

指示指定的 Unicode 字元是否分類為泛空白字元。
IsWhiteSpace(String, Int32)

指示指定的字串中指定位置處的字元是否分類為泛空白字元。
Parse(String)

將指定的字串值轉換成它的對等 Unicode 字元。
ToLower(Char)

將 Unicode 字元值轉換成它的對等小寫。
ToLower(Char, CultureInfo)

使用指定的特定文化特性格式資訊，將指定的 Unicode 字元值轉換成它的對等小寫。
ToLowerInvariant(Char)

使用不因文化特性而異 (Invariant Culture) 的轉換規則，將 Unicode 字元的值轉換成其小寫的同等項目。
ToString()

將這個執行個體的值轉換為它的相等字串表示。
ToString(Char)

將指定的 Unicode 字元轉換成它的對等字串表示。
ToString(IFormatProvider)

使用指定的特定文化特性的格式資訊，將這個執行個體的值轉換為它的對等字串表示。
ToUpper(Char)

將 Unicode 字元值轉換成它的對等大寫。
ToUpper(Char, CultureInfo)

使用指定的特定文化特性格式資訊，將指定的 Unicode 字元值轉換成它的對等大寫。
ToUpperInvariant(Char)

使用不因文化特性而異的轉換規則，將 Unicode 字元的值轉換成其大寫的同等項目。
TryParse(String, Char)

將指定的字串值轉換成它的對等 Unicode 字元。 傳回碼 (Return Code) 會指出轉換是成功或是失敗。

明確介面實作

IBinaryInteger<Char>.GetByteCount()

取得將寫入為 的 TryWriteLittleEndian(Span<Byte>, Int32) 位元組數目。
IBinaryInteger<Char>.GetShortestBitLength()

取得最小兩個補數標記法目前值的長度，以位為單位。
IBinaryInteger<Char>.TryWriteBigEndian(Span<Byte>, Int32)

嘗試以大到大到大的格式，將目前的值寫入指定的範圍。
IBinaryInteger<Char>.TryWriteLittleEndian(Span<Byte>, Int32)

嘗試以位元組端格式將目前的值寫入指定的範圍。
IComparable.CompareTo(Object)

將目前的執行個體與相同類型的另一個物件相比較，並傳回整數，這個整數表示目前的執行個體在排序次序中，位於另一個物件之前、之後或相同位置。
IConvertible.GetTypeCode()

傳回這個執行個體的 TypeCode。
IConvertible.ToBoolean(IFormatProvider)

注意：不支援這項轉換。 嘗試這麼做會擲回 InvalidCastException。
IConvertible.ToByte(IFormatProvider)

如需這個成員的說明，請參閱 ToByte(IFormatProvider)。
IConvertible.ToChar(IFormatProvider)

如需這個成員的說明，請參閱 ToChar(IFormatProvider)。
IConvertible.ToDateTime(IFormatProvider)

注意：不支援這項轉換。 嘗試這麼做會擲回 InvalidCastException。
IConvertible.ToDecimal(IFormatProvider)

注意：不支援這項轉換。 嘗試這麼做會擲回 InvalidCastException。
IConvertible.ToDouble(IFormatProvider)

注意：不支援這項轉換。 嘗試這麼做會擲回 InvalidCastException。
IConvertible.ToInt16(IFormatProvider)

如需這個成員的說明，請參閱 ToInt16(IFormatProvider)。
IConvertible.ToInt32(IFormatProvider)

如需這個成員的說明，請參閱 ToInt32(IFormatProvider)。
IConvertible.ToInt64(IFormatProvider)

如需這個成員的說明，請參閱 ToInt64(IFormatProvider)。
IConvertible.ToSByte(IFormatProvider)

如需這個成員的說明，請參閱 ToSByte(IFormatProvider)。
IConvertible.ToSingle(IFormatProvider)

注意：不支援這項轉換。 嘗試這麼做會擲回 InvalidCastException。
IConvertible.ToString(IFormatProvider)

使用指定限定文化特性的格式資訊，將此執行個體的值轉換為相等字串。
IConvertible.ToType(Type, IFormatProvider)

如需這個成員的說明，請參閱 ToType(Type, IFormatProvider)。
IConvertible.ToUInt16(IFormatProvider)

如需這個成員的說明，請參閱 ToUInt16(IFormatProvider)。
IConvertible.ToUInt32(IFormatProvider)

如需這個成員的說明，請參閱 ToUInt32(IFormatProvider)。
IConvertible.ToUInt64(IFormatProvider)

如需這個成員的說明，請參閱 ToUInt64(IFormatProvider)。
IFormattable.ToString(String, IFormatProvider)

使用指定的格式，格式化目前執行個體的值。
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

嘗試將目前實例的值格式化為提供的字元範圍。

適用於

執行緒安全性

此類型的所有成員都是安全線程。 看似修改實例狀態的成員，實際上會傳回以新值初始化的新實例。 如同任何其他類型，讀取和寫入包含此類型實例的共用變數必須受到鎖定保護，以確保執行緒安全。

另請參閱