Char 结构

定义

命名空间:: System

程序集:: mscorlib.dll, System.Runtime.dll

程序集:: netstandard.dll, System.Runtime.dll

程序集:: System.Runtime.dll

程序集:: mscorlib.dll

程序集:: netstandard.dll

Source:: Char.cs

Source:: Char.cs

Source:: Char.cs

Source:: Char.cs

Source:: Char.cs

重要

一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。

将字符表示为 UTF-16 代码单元。

public value class char : IComparable, IComparable<char>, IConvertible, IEquatable<char>

public value class char : IComparable<char>, IConvertible, IEquatable<char>, IParsable<char>, ISpanParsable<char>, IUtf8SpanParsable<char>, System::Numerics::IAdditionOperators<char, char, char>, System::Numerics::IAdditiveIdentity<char, char>, System::Numerics::IBinaryInteger<char>, System::Numerics::IBinaryNumber<char>, System::Numerics::IBitwiseOperators<char, char, char>, System::Numerics::IComparisonOperators<char, char, bool>, System::Numerics::IDecrementOperators<char>, System::Numerics::IDivisionOperators<char, char, char>, System::Numerics::IEqualityOperators<char, char, bool>, System::Numerics::IIncrementOperators<char>, System::Numerics::IMinMaxValue<char>, System::Numerics::IModulusOperators<char, char, char>, System::Numerics::IMultiplicativeIdentity<char, char>, System::Numerics::IMultiplyOperators<char, char, char>, System::Numerics::INumber<char>, System::Numerics::INumberBase<char>, System::Numerics::IShiftOperators<char, int, char>, System::Numerics::ISubtractionOperators<char, char, char>, System::Numerics::IUnaryNegationOperators<char, char>, System::Numerics::IUnaryPlusOperators<char, char>, System::Numerics::IUnsignedNumber<char>

public 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<char>, IConvertible, IEquatable<char>, IParsable<char>, ISpanParsable<char>, IUtf8SpanParsable<char>, System.Numerics.IAdditionOperators<char,char,char>, System.Numerics.IAdditiveIdentity<char,char>, System.Numerics.IBinaryInteger<char>, System.Numerics.IBinaryNumber<char>, System.Numerics.IBitwiseOperators<char,char,char>, System.Numerics.IComparisonOperators<char,char,bool>, System.Numerics.IDecrementOperators<char>, System.Numerics.IDivisionOperators<char,char,char>, System.Numerics.IEqualityOperators<char,char,bool>, System.Numerics.IIncrementOperators<char>, System.Numerics.IMinMaxValue<char>, System.Numerics.IModulusOperators<char,char,char>, System.Numerics.IMultiplicativeIdentity<char,char>, System.Numerics.IMultiplyOperators<char,char,char>, System.Numerics.INumber<char>, System.Numerics.INumberBase<char>, System.Numerics.IShiftOperators<char,int,char>, System.Numerics.ISubtractionOperators<char,char,char>, System.Numerics.IUnaryNegationOperators<char,char>, System.Numerics.IUnaryPlusOperators<char,char>, System.Numerics.IUnsignedNumber<char>

public readonly struct Char : IComparable, 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 IFormattable
    interface IParsable<char>
    interface ISpanFormattable
    interface ISpanParsable<char>
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<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>

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>

type char = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<char>
    interface ISpanFormattable
    interface ISpanParsable<char>
    interface IAdditionOperators<char, char, char>
    interface IAdditiveIdentity<char, char>
    interface IBinaryInteger<char>
    interface IBinaryNumber<char>
    interface IBitwiseOperators<char, char, char>
    interface IComparisonOperators<char, char, bool>
    interface IEqualityOperators<char, char, bool>
    interface IDecrementOperators<char>
    interface IDivisionOperators<char, char, char>
    interface IIncrementOperators<char>
    interface IModulusOperators<char, char, char>
    interface IMultiplicativeIdentity<char, char>
    interface IMultiplyOperators<char, char, char>
    interface INumber<char>
    interface INumberBase<char>
    interface ISubtractionOperators<char, char, char>
    interface IUnaryNegationOperators<char, char>
    interface IUnaryPlusOperators<char, char>
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<char>
    interface IShiftOperators<char, int, char>
    interface IMinMaxValue<char>
    interface IUnsignedNumber<char>

[<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 IAdditionOperators(Of Char, Char, Char), IAdditiveIdentity(Of Char, Char), IBinaryInteger(Of Char), IBinaryNumber(Of Char), IBitwiseOperators(Of Char, Char, Char), IComparable(Of Char), IComparisonOperators(Of Char, Char, Boolean), IConvertible, IDecrementOperators(Of Char), IDivisionOperators(Of Char, Char, Char), IEqualityOperators(Of Char, Char, Boolean), IEquatable(Of Char), IIncrementOperators(Of Char), IMinMaxValue(Of Char), IModulusOperators(Of Char, Char, Char), IMultiplicativeIdentity(Of Char, Char), IMultiplyOperators(Of Char, Char, Char), INumber(Of Char), INumberBase(Of Char), IParsable(Of Char), IShiftOperators(Of Char, Integer, Char), ISpanParsable(Of Char), ISubtractionOperators(Of Char, Char, Char), IUnaryNegationOperators(Of Char, Char), IUnaryPlusOperators(Of Char, Char), IUnsignedNumber(Of Char), IUtf8SpanParsable(Of Char)

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> IComparable<TSelf> IEquatable<TSelf> IFormattable IParsable<Char> IParsable<TSelf> ISpanFormattable ISpanParsable<Char> ISpanParsable<TSelf> IUtf8SpanFormattable IUtf8SpanParsable<Char> IUtf8SpanParsable<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 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

注解

该 Char 结构使用 UTF-16 编码表示 Unicode 码位。对象的值 Char 是它的 16 位数字（序号）值。

如果不熟悉 Unicode、标量值、码位、代理项对、UTF-16 和 Rune 类型，请参阅 .NET 中的字符编码简介。

本文探讨对象与字符之间的关系 Char ，并讨论使用 Char 实例执行的一些常见任务。建议考虑 .NET Core 3.0 中引入的 Rune 类型，作为执行其中一些任务时替代 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 Example1
{
    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:
//       ä

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:
//       ä

Imports System.IO

Module Example2
    Public Sub Main()
        Dim sw As New StreamWriter("chars1.txt")
        Dim chars() As Char = {ChrW(&H61), ChrW(&H308)}
        Dim strng As New String(chars)
        sw.WriteLine(strng)
        sw.Close()
    End Sub
End Module
' The example produces the following output:
'       ä

Unicode 基本多语言平面 (BMP) 外部的字符。除表示平面 0 的 BMP 之外，Unicode 还支持 16 个平面。 Unicode 代码点由包含平面的 21 位值在 UTF-32 中表示。例如，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 Example3
{
    public static void Main()
    {
        StreamWriter sw = new StreamWriter(@".\chars2.txt");
        int utf32 = 0x1D160;
        string surrogate = Char.ConvertFromUtf32(utf32);
        sw.WriteLine($"U+{utf32:X6} UTF-32 = {surrogate} ({ShowCodePoints(surrogate)}) UTF-16");
        sw.Close();
    }

    private static string ShowCodePoints(string value)
    {
        string retval = null;
        foreach (var ch in value)
            retval += $"U+{Convert.ToUInt16(ch):X4} ";

        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 Example4
    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.CurrencySymbol， UnicodeCategory.LowercaseLetter以及 UnicodeCategory.SpaceSeparator。

若要确定字符的 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($"'{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 Example1
    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 类别。 Unicode 字符根据 Unicode 标准版本 8.0.0 进行分类。

字符和文本元素

由于单个字符可以由多个 Char 对象表示，因此处理单个 Char 对象并不总是有意义的。例如，以下示例将表示爱琴海数字零到 9 的 Unicode 码位转换为 UTF-16 编码的代码单元。因为它错误地将 Char 对象与字符相等，因此它不准确地报告生成的字符串有 20 个字符。

using System;

public class Example5
{
    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 {result.Length} characters.");
    }
}
// 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 Example5
    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 组成的字符串中的文本元素数。因为它认为代理项对是单个字符，所以它正确地报告该字符串包含 10 个字符。

using System;
using System.Globalization;

public class Example4
{
    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 {si.LengthInTextElements} characters.");
    }
}
// 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 Example6
    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（组合分音符）转换为 U+00E4（带分音符的拉丁文小写字母 A）。

using System;

public class Example2
{
    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: {s.Length} (");
        for (int ctr = 0; ctr < s.Length; ctr++)
        {
            Console.Write($"U+{Convert.ToUInt16(s[ctr]):X4}");
            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 Example3
    Public Sub Main()
        Dim combining As String = ChrW(&H61) + ChrW(&H308)
        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、IsPunctuation、IsSeparator、IsSurrogate、IsSurrogatePair、IsSymbol、IsUpper和IsWhiteSpace 另请参阅有关 Rune 该类型的相应方法。
将 Char 表示数字的对象转换为数值类型	GetNumericValue 另请参阅 Rune.GetNumericValue。
将字符串中的字符转换为 Char 对象	Parse 和 TryParse
将 Char 对象转换为 String 对象	ToString
更改Char对象的大小写	ToLower、ToLowerInvariant、ToUpper 和 ToUpperInvariant 另请参阅有关 Rune 该类型的相应方法。

字符值和互操作

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

字段

名称	说明
MaxValue	表示 a 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, StringComparison)	将字符表示为 UTF-16 代码单元。
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` ASCII `c` 字符（[ 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, CultureInfo)	使用指定的区域性特定的格式设置信息将指定的 Unicode 字符的值转换为其小写等效项。
ToLower(Char)	将 Unicode 字符的值转换为其小写等效项。
ToLowerInvariant(Char)	使用固定区域性的大小写规则将 Unicode 字符的值转换为其小写等效项。
ToString()	将此实例的值转换为其等效的字符串表示形式。
ToString(Char)	将指定的 Unicode 字符转换为其等效的字符串表示形式。
ToString(IFormatProvider)	使用指定的区域性特定格式信息将此实例的值转换为其等效的字符串表示形式。
ToUpper(Char, CultureInfo)	使用指定的区域性特定的格式设置信息将指定的 Unicode 字符的值转换为其大写等效项。
ToUpper(Char)	将 Unicode 字符的值转换为其大写等效项。
ToUpperInvariant(Char)	使用固定区域性的大小写规则将 Unicode 字符的值转换为其大写等效项。
TryParse(String, Char)	将指定字符串的值转换为其等效的 Unicode 字符。返回代码指示转换是成功还是失败。

显式接口实现

名称	说明
IAdditionOperators<Char,Char,Char>.Addition(Char, Char)	将两个值相加以计算其总和。
IAdditionOperators<Char,Char,Char>.CheckedAddition(Char, Char)	将两个值相加以计算其总和。
IAdditiveIdentity<Char,Char>.AdditiveIdentity	获取当前类型的累加标识。
IBinaryInteger<Char>.GetByteCount()	获取将作为其一部分 TryWriteLittleEndian(Span<Byte>, Int32)写入的字节数。
IBinaryInteger<Char>.GetShortestBitLength()	获取最短的两个当前值的补数表示形式的长度（以位为单位）。
IBinaryInteger<Char>.LeadingZeroCount(Char)	计算值中的前导零位数。
IBinaryInteger<Char>.Log10(Char)	将字符表示为 UTF-16 代码单元。
IBinaryInteger<Char>.PopCount(Char)	计算值中设置的位数。
IBinaryInteger<Char>.RotateLeft(Char, Int32)	按给定量旋转一个值。
IBinaryInteger<Char>.RotateRight(Char, Int32)	按给定的量向右旋转值。
IBinaryInteger<Char>.TrailingZeroCount(Char)	计算值中尾随零位的数目。
IBinaryInteger<Char>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Char)	将字符表示为 UTF-16 代码单元。
IBinaryInteger<Char>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Char)	将字符表示为 UTF-16 代码单元。
IBinaryInteger<Char>.TryWriteBigEndian(Span<Byte>, Int32)	尝试将当前值（采用 big-endian 格式）写入给定范围。
IBinaryInteger<Char>.TryWriteLittleEndian(Span<Byte>, Int32)	尝试将当前值（以小端格式）写入给定范围。
IBinaryNumber<Char>.AllBitsSet	获取在其中设置所有位的二进制类型的实例。
IBinaryNumber<Char>.IsPow2(Char)	确定值是否为 2 的幂。
IBinaryNumber<Char>.Log2(Char)	计算值的 log2。
IBitwiseOperators<Char,Char,Char>.BitwiseAnd(Char, Char)	计算两个值的按位和两个值。
IBitwiseOperators<Char,Char,Char>.BitwiseOr(Char, Char)	计算两个值的按位或两个值。
IBitwiseOperators<Char,Char,Char>.ExclusiveOr(Char, Char)	计算独占值或两个值。
IBitwiseOperators<Char,Char,Char>.OnesComplement(Char)	计算给定值的补补表示形式。
IComparable.CompareTo(Object)	将当前实例与同一类型的另一个对象进行比较，并返回一个整数，该整数指示当前实例在排序顺序中是位于排序顺序中的同一位置、之后还是位于同一位置。
IComparisonOperators<Char,Char,Boolean>.GreaterThan(Char, Char)	比较两个值以确定哪个值更大。
IComparisonOperators<Char,Char,Boolean>.GreaterThanOrEqual(Char, Char)	比较两个值以确定哪个值更大或相等。
IComparisonOperators<Char,Char,Boolean>.LessThan(Char, Char)	比较两个值以确定哪个值更少。
IComparisonOperators<Char,Char,Boolean>.LessThanOrEqual(Char, Char)	比较两个值以确定哪个值小于或等于。
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)。
IDecrementOperators<Char>.CheckedDecrement(Char)	递减值。
IDecrementOperators<Char>.Decrement(Char)	递减值。
IDivisionOperators<Char,Char,Char>.Division(Char, Char)	将一个值除以计算其商。
IEqualityOperators<Char,Char,Boolean>.Equality(Char, Char)	比较两个值以确定相等性。
IEqualityOperators<Char,Char,Boolean>.Inequality(Char, Char)	比较两个值以确定不相等性。
IFormattable.ToString(String, IFormatProvider)	使用指定格式设置当前实例的值的格式。
IIncrementOperators<Char>.CheckedIncrement(Char)	递增值。
IIncrementOperators<Char>.Increment(Char)	递增值。
IMinMaxValue<Char>.MaxValue	获取当前类型的最大值。
IMinMaxValue<Char>.MinValue	获取当前类型的最小值。
IModulusOperators<Char,Char,Char>.Modulus(Char, Char)	将两个值相除以计算其模数或余数。
IMultiplicativeIdentity<Char,Char>.MultiplicativeIdentity	获取当前类型的乘法标识。
IMultiplyOperators<Char,Char,Char>.CheckedMultiply(Char, Char)	将两个值相乘以计算其产品。
IMultiplyOperators<Char,Char,Char>.Multiply(Char, Char)	将两个值相乘以计算其产品。
INumberBase<Char>.Abs(Char)	计算值的绝对值。
INumberBase<Char>.IsCanonical(Char)	确定某个值是否在其规范表示形式中。
INumberBase<Char>.IsComplexNumber(Char)	确定值是否表示复数。
INumberBase<Char>.IsEvenInteger(Char)	确定值是否表示偶数。
INumberBase<Char>.IsFinite(Char)	确定值是否有限。
INumberBase<Char>.IsImaginaryNumber(Char)	确定值是否表示纯虚数。
INumberBase<Char>.IsInfinity(Char)	确定值是否无限。
INumberBase<Char>.IsInteger(Char)	确定值是否表示整数。
INumberBase<Char>.IsNaN(Char)	确定值是否为 NaN。
INumberBase<Char>.IsNegative(Char)	确定值是否为负值。
INumberBase<Char>.IsNegativeInfinity(Char)	确定值是否为负无穷大。
INumberBase<Char>.IsNormal(Char)	确定值是否正常。
INumberBase<Char>.IsOddInteger(Char)	确定值是否表示奇数整数。
INumberBase<Char>.IsPositive(Char)	确定值是否为正值。
INumberBase<Char>.IsPositiveInfinity(Char)	确定值是否为正无穷大。
INumberBase<Char>.IsRealNumber(Char)	确定值是否表示实数。
INumberBase<Char>.IsSubnormal(Char)	确定某个值是否为非正常值。
INumberBase<Char>.IsZero(Char)	确定值是否为零。
INumberBase<Char>.MaxMagnitude(Char, Char)	比较两个值与计算值更大。
INumberBase<Char>.MaxMagnitudeNumber(Char, Char)	将两个值与计算进行比较，如果输入 `NaN`是，则返回另一个值。
INumberBase<Char>.MinMagnitude(Char, Char)	比较两个值与计算值较小。
INumberBase<Char>.MinMagnitudeNumber(Char, Char)	将两个值与计算进行比较，如果输入 `NaN`是，则返回另一个值。
INumberBase<Char>.MultiplyAddEstimate(Char, Char, Char)	计算估计值（`left` * `right`） + 。 `addend`
INumberBase<Char>.One	获取类型的值 `1` 。
INumberBase<Char>.Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	将字符的范围分析为值。
INumberBase<Char>.Parse(String, NumberStyles, IFormatProvider)	将字符串分析为值。
INumberBase<Char>.Radix	获取类型的基数。
INumberBase<Char>.TryConvertFromChecked<TOther>(TOther, Char)	将字符表示为 UTF-16 代码单元。
INumberBase<Char>.TryConvertFromSaturating<TOther>(TOther, Char)	将字符表示为 UTF-16 代码单元。
INumberBase<Char>.TryConvertFromTruncating<TOther>(TOther, Char)	将字符表示为 UTF-16 代码单元。
INumberBase<Char>.TryConvertToChecked<TOther>(Char, TOther)	尝试将当前类型的实例转换为另一种类型，为超出当前类型可表示范围的任何值引发溢出异常。
INumberBase<Char>.TryConvertToSaturating<TOther>(Char, TOther)	尝试将当前类型的实例转换为另一种类型，使超出当前类型的可表示范围的任何值饱和。
INumberBase<Char>.TryConvertToTruncating<TOther>(Char, TOther)	尝试将当前类型的实例转换为另一种类型，截断属于当前类型的可表示范围之外的任何值。
INumberBase<Char>.TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Char)	将字符表示为 UTF-16 代码单元。
INumberBase<Char>.TryParse(String, NumberStyles, IFormatProvider, Char)	将字符表示为 UTF-16 代码单元。
INumberBase<Char>.Zero	获取类型的值 `0` 。
IParsable<Char>.Parse(String, IFormatProvider)	将字符串分析为值。
IParsable<Char>.TryParse(String, IFormatProvider, Char)	将字符表示为 UTF-16 代码单元。
IShiftOperators<Char,Int32,Char>.LeftShift(Char, Int32)	将一个值左移一个给定的量。
IShiftOperators<Char,Int32,Char>.RightShift(Char, Int32)	将值右移一个给定的量。
IShiftOperators<Char,Int32,Char>.UnsignedRightShift(Char, Int32)	将值右移一个给定的量。
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	尝试将当前实例的值格式化为提供的字符范围。
ISpanParsable<Char>.Parse(ReadOnlySpan<Char>, IFormatProvider)	将字符的范围分析为值。
ISpanParsable<Char>.TryParse(ReadOnlySpan<Char>, IFormatProvider, Char)	将字符表示为 UTF-16 代码单元。
ISubtractionOperators<Char,Char,Char>.CheckedSubtraction(Char, Char)	减去两个值以计算其差异。
ISubtractionOperators<Char,Char,Char>.Subtraction(Char, Char)	减去两个值以计算其差异。
IUnaryNegationOperators<Char,Char>.CheckedUnaryNegation(Char)	计算值选中的一元求反。
IUnaryNegationOperators<Char,Char>.UnaryNegation(Char)	计算值的一元求反。
IUnaryPlusOperators<Char,Char>.UnaryPlus(Char)	计算一元加值。
IUtf8SpanFormattable.TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	尝试将当前实例的值格式化为 UTF-8，并将其设置为提供的字节范围。
IUtf8SpanParsable<Char>.Parse(ReadOnlySpan<Byte>, IFormatProvider)	将字符表示为 UTF-16 代码单元。
IUtf8SpanParsable<Char>.TryParse(ReadOnlySpan<Byte>, IFormatProvider, Char)	将字符表示为 UTF-16 代码单元。

适用于

线程安全性

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

另请参阅

反馈

此页面是否有帮助？