Char Estrutura

Definição

Namespace:

System

Assembly:

System.Runtime.dll

Representa um caractere como uma unidade de código UTF-16.

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

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>

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)

Herança

Object

ValueType

Char

Implementações

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>

Exemplos

O exemplo de código a seguir demonstra alguns dos métodos em 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

Comentários

O .NET usa a Char estrutura para representar pontos de código Unicode usando a codificação UTF-16. O valor de um Char objeto é seu valor numérico (ordinal) de 16 bits.

Se você não estiver familiarizado com Unicode, valores escalares, pontos de código, pares alternativos, UTF-16 e o Rune tipo, consulte Introdução à codificação de caracteres no .NET.

As seções a seguir examinam a relação entre um Char objeto e um caractere e discutem algumas tarefas comuns executadas com Char instâncias. Recomendamos que você considere o Rune tipo, introduzido no .NET Core 3.0, como uma alternativa para Char executar algumas dessas tarefas.

• Objetos Char, caracteres Unicode e cadeias de caracteres
• Caracteres e categorias de caracteres
• Caracteres e elementos de texto
• Operações comuns
• Valores char e interoperabilidade

Objetos Char, caracteres Unicode e cadeias de caracteres

Um String objeto é uma coleção sequencial de Char estruturas que representa uma cadeia de caracteres de texto. A maioria dos caracteres Unicode pode ser representada por um único Char objeto, mas um caractere codificado como um caractere base, par alternativo e/ou combinação de sequência de caracteres é representado por vários Char objetos. Por esse motivo, uma Char estrutura em um String objeto não é necessariamente equivalente a um único caractere Unicode.

Várias unidades de código de 16 bits são usadas para representar caracteres Unicode únicos nos seguintes casos:

• Glifos, que podem consistir em um único caractere ou de um caractere base seguido por um ou mais caracteres de combinação. Por exemplo, o caractere ä é representado por um Char objeto cuja unidade de código é U+0061 seguida por um Char objeto cuja unidade de código é U+0308. (O caractere ä também pode ser definido por um único Char objeto que tem uma unidade de código de U+00E4.) O exemplo a seguir ilustra que o caractere ä consiste em dois Char objetos.

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

• Caracteres fora do Plano Multilíngue Básico Unicode (BMP). O Unicode dá suporte a dezesseis planos além do BMP, que representa o plano 0. Um ponto de código Unicode é representado em UTF-32 por um valor de 21 bits que inclui o plano. Por exemplo, U+1D160 representa o caractere MUSICAL SYMBOL EIGHT NOTE. Como a codificação UTF-16 tem apenas 16 bits, os caracteres fora do BMP são representados por pares alternativos em UTF-16. O exemplo a seguir ilustra que o equivalente UTF-32 de U+1D160, o caractere SÍMBOLO MUSICAL OITAVO NOTA, é U+D834 U+DD60. U+D834 é o substituto alto; substitutos altos variam de U+D800 a U+DBFF. U+DD60 é o substituto baixo; substitutos baixos variam de U+DC00 a 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
  

Caracteres e categorias de caracteres

Cada caractere Unicode ou par alternativo válido pertence a uma categoria Unicode. No .NET, as categorias Unicode são representadas por membros da UnicodeCategory enumeração e incluem valores como UnicodeCategory.CurrencySymbol, UnicodeCategory.LowercaseLettere UnicodeCategory.SpaceSeparator, por exemplo.

Para determinar a categoria Unicode de um caractere, chame o GetUnicodeCategory método . Por exemplo, o exemplo a seguir chama o GetUnicodeCategory para exibir a categoria Unicode de cada caractere em uma cadeia de caracteres. O exemplo funciona corretamente somente se não houver pares substitutos na String instância.

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

Internamente, para caracteres fora do intervalo ASCII (U+0000 a U+00FF), o método depende das GetUnicodeCategory categorias Unicode relatadas pela CharUnicodeInfo classe . A partir do .NET Framework 4.6.2, os caracteres Unicode são classificados com base no Padrão Unicode, versão 8.0.0. Em versões do .NET Framework de .NET Framework 4 a .NET Framework 4.6.1, elas são classificadas com base no Padrão Unicode, versão 6.3.0.

Caracteres e elementos de texto

Como um único caractere pode ser representado por vários Char objetos, nem sempre é significativo trabalhar com objetos individuais Char . Por exemplo, o exemplo a seguir converte os pontos de código Unicode que representam os números Egeu zero a 9 em unidades de código codificadas em UTF-16. Como ele iguala Char erroneamente objetos com caracteres, ele relata incorretamente que a cadeia de caracteres resultante tem 20 caracteres.

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.

Você pode fazer o seguinte para evitar a suposição de que um Char objeto representa um único caractere:

• Você pode trabalhar com um String objeto em sua totalidade em vez de trabalhar com seus caracteres individuais para representar e analisar o conteúdo linguístico.

• Você pode usar String.EnumerateRunes conforme mostrado no exemplo a seguir:

  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
  

• Você pode usar a StringInfo classe para trabalhar com elementos de texto em vez de objetos individuais Char . O exemplo a seguir usa o StringInfo objeto para contar o número de elementos de texto em uma cadeia de caracteres que consiste nos números Egeu de zero a nove. Como ele considera um par alternativo um único caractere, ele relata corretamente que a cadeia de caracteres contém dez caracteres.

  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.
  

• Se uma cadeia de caracteres contiver um caractere base que tenha um ou mais caracteres de combinação, você poderá chamar o String.Normalize método para converter a subcadeia de caracteres em uma única unidade de código codificada em UTF-16. O exemplo a seguir chama o String.Normalize método para converter o caractere base U+0061 (LATIN SMALL LETTER A) e combinar o caractere U+0308 (COMBINING DIAERESIS) em 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)
  

Operações comuns

A Char estrutura fornece métodos para comparar Char objetos, converter o valor do objeto atual Char em um objeto de outro tipo e determinar a categoria Unicode de um Char objeto:

Para fazer isto	Usar esses System.Char métodos
Comparar Char objetos	CompareTo e Equals
Converter um ponto de código em uma cadeia de caracteres	ConvertFromUtf32 Consulte também o Rune tipo .
Converter um Char objeto ou um par alternativo de objetos em um ponto de Char código	Para um único caractere: Convert.ToInt32(Char) Para um par alternativo ou um caractere em uma cadeia de caracteres: Char.ConvertToUtf32 Consulte também o Rune tipo .
Obter a categoria Unicode de um caractere	GetUnicodeCategory Consulte também Rune.GetUnicodeCategory.
Determinar se um caractere está em uma categoria Unicode específica, como dígito, letra, pontuação, caractere de controle e assim por diante	IsControl, IsDigit, IsHighSurrogate, IsLetter, IsLetterOrDigit, IsLower, , IsNumberIsLowSurrogate, IsPunctuation, IsSeparator, IsSurrogate, IsSurrogatePair, IsSymbol, , IsUppereIsWhiteSpace Consulte também os métodos correspondentes no Rune tipo .
Converter um Char objeto que representa um número em um tipo de valor numérico	GetNumericValue Consulte também Rune.GetNumericValue.
Converter um caractere em uma cadeia de caracteres em um Char objeto	Parse e TryParse
Converter um Char objeto em um String objeto	ToString
Alterar o caso de um Char objeto	ToLower, ToLowerInvariant, ToUpper e ToUpperInvariant Consulte também os métodos correspondentes no Rune tipo .

Valores char e interoperabilidade

Quando um tipo gerenciado Char , que é representado como uma unidade de código codificada unicode UTF-16, é passado para código não gerenciado, o marshaler de interoperabilidade converte o conjunto de caracteres em ANSI por padrão. Você pode aplicar o DllImportAttribute atributo a declarações de invocação de plataforma e o StructLayoutAttribute atributo a uma declaração de interoperabilidade COM para controlar qual conjunto de caracteres um tipo marshaled Char usa.

Campos

MaxValue	Representa o maior valor possível de um Char. Este campo é constante.
MinValue	Representa o menor valor possível de um Char. Este campo é constante.

Métodos

CompareTo(Char)	Compara essa instância com um objeto Char especificado e indica se a instância precede, segue ou aparece na mesma posição na ordem de classificação que o objeto Char especificado.
CompareTo(Object)	Compara essa instância com um objeto especificado e indica se a instância precede, segue ou aparece na mesma posição na ordem de classificação que o Object especificado.
ConvertFromUtf32(Int32)	Converte o ponto de código Unicode especificado em uma cadeia de caracteres codificada para UTF-16.
ConvertToUtf32(Char, Char)	Converte o valor de um par alternativo do UTF-16 codificado em um ponto de código Unicode.
ConvertToUtf32(String, Int32)	Converte o valor de um par substituto ou caractere codificado em UTF-16 em uma posição especificada em uma cadeia de caracteres em um ponto de código Unicode.
Equals(Char)	Retorna um valor que indica se essa instância é igual ao objeto Char especificado.
Equals(Object)	Retorna um valor que indica se essa instância é igual a um objeto especificado.
GetHashCode()	Retorna o código hash para a instância.
GetNumericValue(Char)	Converte o caractere Unicode numérico especificado em um número de ponto flutuante de precisão dupla.
GetNumericValue(String, Int32)	Converte o caractere Unicode numérico na posição especificada contido em uma cadeia de caracteres especificada em um número de ponto flutuante de precisão dupla.
GetTypeCode()	Retorna o TypeCode para tipo de valor Char.
GetUnicodeCategory(Char)	Categoriza um caractere Unicode especificado em um grupo identificado por um dos valores de UnicodeCategory.
GetUnicodeCategory(String, Int32)	Categoriza o caractere na posição especificada em uma cadeia de caracteres especificada em um grupo identificado por um dos valores de UnicodeCategory.
IsAscii(Char)	Retorna true se c for um caractere ASCII ([ U+0000..U+007F ]).
IsAsciiDigit(Char)	Indica se um caractere é categorizado como um dígito ASCII.
IsAsciiHexDigit(Char)	Indica se um caractere é categorizado como um dígito hexadêmico ASCII.
IsAsciiHexDigitLower(Char)	Indica se um caractere é categorizado como um dígito hexadêmico de letras minúsculas ASCII.
IsAsciiHexDigitUpper(Char)	Indica se um caractere é categorizado como um dígito hexadêmico de maiúsculas e minúsculas ASCII.
IsAsciiLetter(Char)	Indica se um caractere é categorizado como uma letra ASCII.
IsAsciiLetterLower(Char)	Indica se um caractere é categorizado como uma letra ASCII minúscula.
IsAsciiLetterOrDigit(Char)	Indica se um caractere é categorizado como uma letra ou dígito ASCII.
IsAsciiLetterUpper(Char)	Indica se um caractere é categorizado como uma letra ASCII maiúscula.
IsBetween(Char, Char, Char)	Indica se um caractere está dentro do intervalo inclusivo especificado.
IsControl(Char)	Indica se o caractere Unicode especificado é categorizado como um caractere de controle.
IsControl(String, Int32)	Indica se o caractere na posição especificada em uma cadeia de caracteres especificada é categorizado como um caractere de controle.
IsDigit(Char)	Indica se o caractere Unicode especificado é categorizado como um dígito decimal.
IsDigit(String, Int32)	Indica se o caractere na posição especificada em uma cadeia de caracteres especificada é categorizado como um dígito decimal.
IsHighSurrogate(Char)	Indica se o objeto Char especificado é um alternativo alto.
IsHighSurrogate(String, Int32)	Indica se o objeto Char na posição especificada em uma cadeia de caracteres é um substituto alto.
IsLetter(Char)	Indica se o caractere Unicode especificado é categorizado como uma letra de Unicode.
IsLetter(String, Int32)	Indica se o caractere na posição especificada em uma cadeia de caracteres especificada é categorizado como uma letra Unicode.
IsLetterOrDigit(Char)	Indica se o caractere Unicode especificado é categorizado como uma letra ou dígito decimal.
IsLetterOrDigit(String, Int32)	Indica se o caractere na posição especificada em uma cadeia de caracteres especificada é categorizado como uma letra ou um dígito decimal.
IsLower(Char)	Indica se o caractere Unicode especificado é categorizado como uma letra minúscula.
IsLower(String, Int32)	Indica se o caractere na posição especificada em uma cadeia de caracteres especificada é categorizado como uma letra maiúscula.
IsLowSurrogate(Char)	Indica se o objeto Char especificado é um alternativo baixo.
IsLowSurrogate(String, Int32)	Indica se o objeto Char na posição especificada em uma cadeia de caracteres é um substituto baixo.
IsNumber(Char)	Indica se o caractere Unicode especificado é categorizado como um número.
IsNumber(String, Int32)	Indica se o caractere na posição especificada em uma cadeia de caracteres especificada é categorizado como um número.
IsPunctuation(Char)	Indica se o caractere Unicode especificado é categorizado como uma marca de pontuação.
IsPunctuation(String, Int32)	Indica se o caractere na posição especificada em uma cadeia de caracteres especificada é categorizado como uma marca de pontuação.
IsSeparator(Char)	Indica se o caractere Unicode especificado é categorizado como um caractere separador.
IsSeparator(String, Int32)	Indica se o caractere na posição especificada em uma cadeia de caracteres especificada é categorizado como um caractere separador.
IsSurrogate(Char)	Indica se o caractere especificado tem uma unidade de código substituta.
IsSurrogate(String, Int32)	Indica se o caractere na posição especificada em uma cadeia de caracteres especificada tem uma unidade de código de substituto.
IsSurrogatePair(Char, Char)	Indica se os dois objetos Char especificados formam um par substituto.
IsSurrogatePair(String, Int32)	Indica se dois objetos Char adjacentes em uma posição especificada em uma cadeia de caracteres formam um par alternativo.
IsSymbol(Char)	Indica se o caractere Unicode especificado é categorizado como um caractere de símbolo.
IsSymbol(String, Int32)	Indica se o caractere na posição especificada em uma cadeia de caracteres especificada é categorizado como um caractere de símbolo.
IsUpper(Char)	Indica se o caractere Unicode especificado é categorizado como uma letra maiúscula.
IsUpper(String, Int32)	Indica se o caractere na posição especificada em uma cadeia de caracteres especificada é categorizado como uma letra maiúscula.
IsWhiteSpace(Char)	Indica se o caractere Unicode especificado é categorizado como um espaço em branco.
IsWhiteSpace(String, Int32)	Indica se o caractere na posição especificada em uma cadeia de caracteres especificada é categorizado como espaços em branco.
Parse(String)	Converte o valor da cadeia de caracteres especificada em seu caractere Unicode equivalente.
ToLower(Char)	Converte o valor de um caractere Unicode em seu equivalente em minúsculas.
ToLower(Char, CultureInfo)	Converte o valor de um caractere Unicode especificado no equivalente em minúsculas usando as informações de formatação específicas à cultura especificadas.
ToLowerInvariant(Char)	Converte o valor de um caractere Unicode para seu equivalente em minúsculas usando as regras de maiúsculas e minúsculas da cultura invariável.
ToString()	Converte o valor dessa instância na representação da cadeia de caracteres equivalente.
ToString(Char)	Converte o caractere Unicode especificado na representação de cadeia de caracteres equivalente.
ToString(IFormatProvider)	Converte o valor dessa instância na representação da cadeia de caracteres equivalente usando as informações de formato específicas da cultura especificada.
ToUpper(Char)	Converte o valor de um caractere Unicode para seu equivalente em maiúsculas.
ToUpper(Char, CultureInfo)	Converte o valor de um caractere Unicode especificado em seu equivalente em letras maiúsculas usando as informações de formatação específicas à cultura especificadas.
ToUpperInvariant(Char)	Converte o valor de um caractere Unicode para seu equivalente em maiúsculas usando as regras de maiúsculas e minúsculas da cultura invariável.
TryParse(String, Char)	Converte o valor da cadeia de caracteres especificada em seu caractere Unicode equivalente. Um código de retorno indica se a conversão foi bem-sucedida ou falhou.

Implantações explícitas de interface

IAdditionOperators<Char,Char,Char>.Addition(Char, Char)	Adiciona dois valores juntos para calcular sua soma.
IAdditionOperators<Char,Char,Char>.CheckedAddition(Char, Char)	Adiciona dois valores juntos para calcular sua soma.
IAdditiveIdentity<Char,Char>.AdditiveIdentity	Obtém a identidade aditiva do tipo atual.
IBinaryInteger<Char>.GetByteCount()	Obtém o número de bytes que serão gravados como parte de TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<Char>.GetShortestBitLength()	Obtém o comprimento, em bits, da representação complementar dos dois mais curtos do valor atual.
IBinaryInteger<Char>.LeadingZeroCount(Char)	Calcula o número de bits zero à esquerda em um valor.
IBinaryInteger<Char>.PopCount(Char)	Calcula o número de bits definidos em um valor.
IBinaryInteger<Char>.RotateLeft(Char, Int32)	Gira um valor deixado por um determinado valor.
IBinaryInteger<Char>.RotateRight(Char, Int32)	Gira um valor para a direita em um determinado valor.
IBinaryInteger<Char>.TrailingZeroCount(Char)	Calcula o número de bits zero à direita em um valor.
IBinaryInteger<Char>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Char)	Representa um caractere como uma unidade de código UTF-16.
IBinaryInteger<Char>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Char)	Representa um caractere como uma unidade de código UTF-16.
IBinaryInteger<Char>.TryWriteBigEndian(Span<Byte>, Int32)	Tenta gravar o valor atual, no formato big-endian, em um determinado intervalo.
IBinaryInteger<Char>.TryWriteLittleEndian(Span<Byte>, Int32)	Tenta gravar o valor atual, no formato little-endian, em um determinado intervalo.
IBinaryNumber<Char>.AllBitsSet	Obtém uma instância do tipo binário no qual todos os bits são definidos.
IBinaryNumber<Char>.IsPow2(Char)	Determina se um valor é uma potência de dois.
IBinaryNumber<Char>.Log2(Char)	Calcula o log2 de um valor.
IBitwiseOperators<Char,Char,Char>.BitwiseAnd(Char, Char)	Calcula o bit a bit e de dois valores.
IBitwiseOperators<Char,Char,Char>.BitwiseOr(Char, Char)	Calcula o bit a bit ou dois valores.
IBitwiseOperators<Char,Char,Char>.ExclusiveOr(Char, Char)	Calcula o exclusivo ou de dois valores.
IBitwiseOperators<Char,Char,Char>.OnesComplement(Char)	Calcula a representação ones-complement de um determinado valor.
IComparisonOperators<Char,Char,Boolean>.GreaterThan(Char, Char)	Compara dois valores para determinar qual é maior.
IComparisonOperators<Char,Char,Boolean>.GreaterThanOrEqual(Char, Char)	Compara dois valores para determinar qual é maior ou igual.
IComparisonOperators<Char,Char,Boolean>.LessThan(Char, Char)	Compara dois valores para determinar qual é menor.
IComparisonOperators<Char,Char,Boolean>.LessThanOrEqual(Char, Char)	Compara dois valores para determinar qual é menor ou igual.
IConvertible.ToBoolean(IFormatProvider)	Observação Não há suporte para esta conversão. A tentativa de fazer isso lança um InvalidCastException.
IConvertible.ToByte(IFormatProvider)	Para obter uma descrição desse membro, confira ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Para obter uma descrição desse membro, confira ToChar(IFormatProvider).
IConvertible.ToDateTime(IFormatProvider)	Observação Não há suporte para esta conversão. A tentativa de fazer isso lança um InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	Observação Não há suporte para esta conversão. A tentativa de fazer isso lança um InvalidCastException.
IConvertible.ToDouble(IFormatProvider)	Observação Não há suporte para esta conversão. A tentativa de fazer isso lança um InvalidCastException.
IConvertible.ToInt16(IFormatProvider)	Para obter uma descrição desse membro, confira ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Para obter uma descrição desse membro, confira ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Para obter uma descrição desse membro, confira ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Para obter uma descrição desse membro, confira ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Observação Não há suporte para esta conversão. A tentativa de fazer isso lança um InvalidCastException.
IConvertible.ToType(Type, IFormatProvider)	Para obter uma descrição desse membro, confira ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Para obter uma descrição desse membro, confira ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Para obter uma descrição desse membro, confira ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Para obter uma descrição desse membro, confira ToUInt64(IFormatProvider).
IDecrementOperators<Char>.CheckedDecrement(Char)	Diminui um valor.
IDecrementOperators<Char>.Decrement(Char)	Diminui um valor.
IDivisionOperators<Char,Char,Char>.Division(Char, Char)	Divide um valor por outro para calcular seu quociente.
IEqualityOperators<Char,Char,Boolean>.Equality(Char, Char)	Compara dois valores para determinar a igualdade.
IEqualityOperators<Char,Char,Boolean>.Inequality(Char, Char)	Compara dois valores para determinar a desigualdade.
IFormattable.ToString(String, IFormatProvider)	Formata o valor da instância atual usando o formato especificado.
IIncrementOperators<Char>.CheckedIncrement(Char)	Incrementa um valor.
IIncrementOperators<Char>.Increment(Char)	Incrementa um valor.
IMinMaxValue<Char>.MaxValue	Obtém o valor máximo do tipo atual.
IMinMaxValue<Char>.MinValue	Obtém o valor mínimo do tipo atual.
IModulusOperators<Char,Char,Char>.Modulus(Char, Char)	Divide dois valores juntos para calcular seu módulo ou resto.
IMultiplicativeIdentity<Char,Char>.MultiplicativeIdentity	Obtém a identidade multiplicativa do tipo atual.
IMultiplyOperators<Char,Char,Char>.CheckedMultiply(Char, Char)	Multiplica dois valores juntos para calcular seu produto.
IMultiplyOperators<Char,Char,Char>.Multiply(Char, Char)	Multiplica dois valores juntos para calcular seu produto.
INumberBase<Char>.Abs(Char)	Calcula o absoluto de um valor.
INumberBase<Char>.IsCanonical(Char)	Determina se um valor está em sua representação canônica.
INumberBase<Char>.IsComplexNumber(Char)	Determina se um valor representa um número complexo.
INumberBase<Char>.IsEvenInteger(Char)	Determina se um valor representa um número integral par.
INumberBase<Char>.IsFinite(Char)	Determina se um valor é finito.
INumberBase<Char>.IsImaginaryNumber(Char)	Determina se um valor representa um número imaginário puro.
INumberBase<Char>.IsInfinity(Char)	Determina se um valor é infinito.
INumberBase<Char>.IsInteger(Char)	Determina se um valor representa um número integral.
INumberBase<Char>.IsNaN(Char)	Determina se um valor é NaN.
INumberBase<Char>.IsNegative(Char)	Determina se um valor é negativo.
INumberBase<Char>.IsNegativeInfinity(Char)	Determina se um valor é infinito negativo.
INumberBase<Char>.IsNormal(Char)	Determina se um valor é normal.
INumberBase<Char>.IsOddInteger(Char)	Determina se um valor representa um número integral ímpar.
INumberBase<Char>.IsPositive(Char)	Determina se um valor é positivo.
INumberBase<Char>.IsPositiveInfinity(Char)	Determina se um valor é infinito positivo.
INumberBase<Char>.IsRealNumber(Char)	Determina se um valor representa um número real.
INumberBase<Char>.IsSubnormal(Char)	Determina se um valor é subnormal.
INumberBase<Char>.IsZero(Char)	Determina se um valor é zero.
INumberBase<Char>.MaxMagnitude(Char, Char)	Compara dois valores com a computação, que é maior.
INumberBase<Char>.MaxMagnitudeNumber(Char, Char)	Compara dois valores com a computação que tem a magnitude maior e retorna o outro valor se uma entrada for NaN.
INumberBase<Char>.MinMagnitude(Char, Char)	Compara dois valores com a computação que é menor.
INumberBase<Char>.MinMagnitudeNumber(Char, Char)	Compara dois valores com a computação que tem a magnitude menor e retorna o outro valor se uma entrada é NaN.
INumberBase<Char>.One	Obtém o valor 1 do tipo.
INumberBase<Char>.Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Analisa um intervalo de caracteres em um valor.
INumberBase<Char>.Parse(String, NumberStyles, IFormatProvider)	Analisa uma cadeia de caracteres em um valor .
INumberBase<Char>.Radix	Obtém a base para o tipo.
INumberBase<Char>.TryConvertFromChecked<TOther>(TOther, Char)	Representa um caractere como uma unidade de código UTF-16.
INumberBase<Char>.TryConvertFromSaturating<TOther>(TOther, Char)	Representa um caractere como uma unidade de código UTF-16.
INumberBase<Char>.TryConvertFromTruncating<TOther>(TOther, Char)	Representa um caractere como uma unidade de código UTF-16.
INumberBase<Char>.TryConvertToChecked<TOther>(Char, TOther)	Tenta converter uma instância do tipo atual em outro tipo, gerando uma exceção de estouro para quaisquer valores que estejam fora do intervalo representável do tipo atual.
INumberBase<Char>.TryConvertToSaturating<TOther>(Char, TOther)	Tenta converter uma instância do tipo atual em outro tipo, saturando todos os valores que estão fora do intervalo representável do tipo atual.
INumberBase<Char>.TryConvertToTruncating<TOther>(Char, TOther)	Tenta converter uma instância do tipo atual em outro tipo, truncando quaisquer valores que estejam fora do intervalo representável do tipo atual.
INumberBase<Char>.TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Char)	Representa um caractere como uma unidade de código UTF-16.
INumberBase<Char>.TryParse(String, NumberStyles, IFormatProvider, Char)	Representa um caractere como uma unidade de código UTF-16.
INumberBase<Char>.Zero	Obtém o valor 0 do tipo.
IParsable<Char>.Parse(String, IFormatProvider)	Analisa uma cadeia de caracteres em um valor .
IParsable<Char>.TryParse(String, IFormatProvider, Char)	Representa um caractere como uma unidade de código UTF-16.
IShiftOperators<Char,Int32,Char>.LeftShift(Char, Int32)	Desloca um valor para a esquerda por um determinado valor.
IShiftOperators<Char,Int32,Char>.RightShift(Char, Int32)	Desloca um valor para a direita em um determinado valor.
IShiftOperators<Char,Int32,Char>.UnsignedRightShift(Char, Int32)	Desloca um valor para a direita em um determinado valor.
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tenta formatar o valor da instância atual no intervalo de caracteres fornecido.
ISpanParsable<Char>.Parse(ReadOnlySpan<Char>, IFormatProvider)	Analisa um intervalo de caracteres em um valor.
ISpanParsable<Char>.TryParse(ReadOnlySpan<Char>, IFormatProvider, Char)	Representa um caractere como uma unidade de código UTF-16.
ISubtractionOperators<Char,Char,Char>.CheckedSubtraction(Char, Char)	Subtrai dois valores para calcular sua diferença.
ISubtractionOperators<Char,Char,Char>.Subtraction(Char, Char)	Subtrai dois valores para calcular sua diferença.
IUnaryNegationOperators<Char,Char>.CheckedUnaryNegation(Char)	Calcula a negação unária verificada de um valor.
IUnaryNegationOperators<Char,Char>.UnaryNegation(Char)	Calcula a negação unária de um valor.
IUnaryPlusOperators<Char,Char>.UnaryPlus(Char)	Calcula a mais unária de um valor.

Acesso thread-safe

Todos os membros desse tipo são thread-safe. Os membros que aparentam modificar efetivamente o estado retornam uma nova instância inicializada com o novo valor. Assim como acontece com qualquer outro tipo, a leitura e a gravação em uma variável compartilhada que contém uma instância desse tipo devem ser protegidas por um bloqueio para garantir thread-safe.

Confira também

• IComparable
• IConvertible
• String