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 对象表示，但编码为基字符、代理项对和/或组合字符序列的字符由多个 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 还支持 16 个平面。 Unicode 码位在 UTF-32 中由包含平面的 21 位值表示。 例如，U+1D160 表示音乐符号第八注字符。 由于 UTF-16 编码只有 16 位，BMP 之外的字符由 UTF-16 中的代理项对表示。 以下示例说明 U+1D160（音乐符号第八注字符）的 UTF-32 等效项是 U+D834 U+DD60。 U+D834 是高代理项;高代理项的范围从 U+D800 到 U+DBFF。 U+DD60 是低代理项;低代理项的范围从 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 字符或有效的代理项对都属于 Unicode 类别。 在 .NET 中，Unicode 类别由 枚举的成员UnicodeCategory表示，并包含 、、 和 UnicodeCategory.SpaceSeparator等UnicodeCategory.CurrencySymbolUnicodeCategory.LowercaseLetter值。

若要确定字符的 Unicode 类别，请调用 GetUnicodeCategory 方法。 例如，以下示例调用 以显示 GetUnicodeCategory 字符串中每个字符的 Unicode 类别。 仅当实例中没有代理项对时， String 该示例才正常工作。

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 标准版本 8.0.0 进行分类。 在从 .NET Framework 4 到 .NET Framework 4.6.1 的.NET Framework版本中，它们基于 Unicode Standard 版本 6.3.0 进行分类。

字符和文本元素

由于单个字符可由多个 Char 对象表示，因此使用单个 Char 对象并不总是有意义的。 例如，以下示例将表示爱琴海数字 0 到 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 对象对由爱琴海数字 0 到 9 组成的字符串中的文本元素数进行计数。 因为它将代理项对视为单个字符，因此它正确报告字符串包含十个字符。

    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 (拉丁文小写字母 A) ，并将字符 U+0308 (COMBINING DIAERESIS) 转换为 U+00E4 (拉丁文小写字母 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 对象的值转换为另一种类型的对象以及确定对象的 Unicode 类别 Char 的方法：

要执行此操作 使用这些 System.Char 方法
比较 Char 对象 CompareTo 和 Equals
将代码点转换为字符串 ConvertFromUtf32

另 Rune 请参阅 类型。
将 Char 对象或代理对象对 Char 转换为代码点 对于单个字符： Convert.ToInt32(Char)

对于代理项对或字符串中的字符： Char.ConvertToUtf32

另 Rune 请参阅 类型。
获取字符的 Unicode 类别 GetUnicodeCategory

另请参阅 Rune.GetUnicodeCategory。
确定字符是否属于特定的 Unicode 类别，例如数字、字母、标点、控制字符等 IsControl、IsDigit、IsHighSurrogate、IsLetter、IsLetterOrDigit、IsLower、IsLowSurrogate、、IsNumber、IsSeparatorIsPunctuation、IsSurrogateIsSurrogatePairIsSymbolIsUpper和IsWhiteSpace

另请参阅类型上的 Rune 相应方法。
将 Char 表示数字的对象转换为数值类型 GetNumericValue

另请参阅 Rune.GetNumericValue。
将字符串中的字符转换为 Char 对象 Parse 和 TryParse
将 Char 对象转换为 String 对象 ToString
更改对象的大小写Char ToLower、ToLowerInvariant、ToUpper 和 ToUpperInvariant

另请参阅类型上的 Rune 相应方法。

Char 值和互操作

将表示为 Unicode UTF-16 编码代码单元的托管 Char 类型传递给非托管代码时，互操作封送处理器默认将字符集转换为 ANSI。 可以将 特性应用于 DllImportAttribute 平台调用声明，将 StructLayoutAttribute 特性应用于 COM 互操作声明，以控制封送 Char 类型使用的字符集。

字段

MaxValue

表示 Char 的最大可能值。 此字段为常数。
MinValue

表示 Char 的最小可能值。 此字段为常数。

方法

CompareTo(Char)

将此实例与指定的 Char 对象进行比较，并指示此实例在排序顺序中是位于指定的 Char 对象之前、之后还是与其出现在同一位置。
CompareTo(Object)

将此实例与指定的对象进行比较，并指示此实例在排序顺序中是位于指定的 Object 之前、之后还是与其出现在同一位置。
ConvertFromUtf32(Int32)

将指定的 Unicode 码位转换为 UTF-16 编码字符串。
ConvertToUtf32(Char, Char)

将 UTF-16 编码的代理项对的值转换为 Unicode 码位。
ConvertToUtf32(String, Int32)

将字符串中指定位置的 UTF-16 编码字符或代理项对的值转换为 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 对象是否是一个高代理项。
IsHighSurrogate(String, Int32)

指示字符串中指定位置处的 Char 对象是否为高代理项。
IsLetter(Char)

指示指定的 Unicode 字符是否属于 Unicode 字母类别。
IsLetter(String, Int32)

指示指定字符串中位于指定位置处的指定字符串是否属于 Unicode 字母类别。
IsLetterOrDigit(Char)

指示指定的 Unicode 字符是否属于字母或十进制数字类别。
IsLetterOrDigit(String, Int32)

指示指定字符串中位于指定位置处的字符是否属于字母或十进制数字类别。
IsLower(Char)

指示指定的 Unicode 字符是否属于小写字母类别。
IsLower(String, Int32)

指示指定字符串中位于指定位置处的字符是否属于小写字母类别。
IsLowSurrogate(Char)

指示指定的 Char 对象是否是一个低代理项。
IsLowSurrogate(String, Int32)

指示字符串中指定位置处的 Char 对象是否为低代理项。
IsNumber(Char)

指示指定的 Unicode 字符是否属于数字类别。
IsNumber(String, Int32)

指示指定字符串中位于指定位置的字符是否属于数字类别。
IsPunctuation(Char)

指示指定的 Unicode 字符是否属于标点符号类别。
IsPunctuation(String, Int32)

指示指定字符串中位于指定位置处的字符是否属于标点符号类别。
IsSeparator(Char)

指示指定的 Unicode 字符是否属于分隔符类别。
IsSeparator(String, Int32)

指示指定字符串中位于指定位置处的字符是否属于分隔符类别。
IsSurrogate(Char)

指示指定的字符是否具有指定的代理项代码单位。
IsSurrogate(String, Int32)

指示指定字符串中位于指定位置的字符是否具有代理项代码单位。
IsSurrogatePair(Char, Char)

指示两个指定的 Char 对象是否形成一个代理项对。
IsSurrogatePair(String, Int32)

指示字符串中指定位置处的两个相邻 Char 对象是否形成一个代理项对。
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)

使用固定区域性的大小写规则，将 Unicode 字符的值转换为其小写等效项。
ToString()

将此实例的值转换为其等效的字符串表示形式。
ToString(Char)

将指定的 Unicode 字符转换为它的等效字符串表示形式。
ToString(IFormatProvider)

使用指定的区域性特定格式信息将此实例的值转换为它的等效字符串表示形式。
ToUpper(Char)

将 Unicode 字符的值转换为它的大写等效项。
ToUpper(Char, CultureInfo)

使用指定的区域性特定格式设置信息将指定 Unicode 字符的值转换为它的大写等效项。
ToUpperInvariant(Char)

使用固定区域性的大小写规则，将 Unicode 字符的值转换为其大写等效项。
TryParse(String, Char)

将指定字符串的值转换为它的等效 Unicode 字符。 一个指示转换是成功还是失败的返回代码。

显式接口实现

IBinaryInteger<Char>.GetByteCount()

获取将作为 的一部分写入的 TryWriteLittleEndian(Span<Byte>, Int32)字节数。
IBinaryInteger<Char>.GetShortestBitLength()

获取当前值的最短两个补补表示形式的长度（以位为单位）。
IBinaryInteger<Char>.TryWriteBigEndian(Span<Byte>, Int32)

尝试以 big-endian 格式将当前值写入给定范围。
IBinaryInteger<Char>.TryWriteLittleEndian(Span<Byte>, Int32)

尝试以 little-endian 格式将当前值写入给定范围。
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)

尝试将当前实例的值格式化为提供的字符范围。

适用于

线程安全性

此类型的所有成员都是线程安全的。 看起来修改实例状态的成员实际上返回使用新值初始化的新实例。 与任何其他类型一样，读取和写入包含此类型的实例的共享变量必须受到锁的保护，以确保线程安全。

另请参阅