Char Estrutura

Definição

Namespace:

System

Assembly:

System.Runtime.dll

Origem:

Char.cs

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

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

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>

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)

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> IUtf8SpanFormattable IUtf8SpanParsable<Char> IUtf8SpanParsable<TSelf>

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

Para obter mais informações sobre essa API, consulte comentários da API Complementar para Char.

Campos

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

Métodos

CompareTo(Char)	Compara essa instância a um objeto Char especificado e indica se essa 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 a um objeto especificado e indica se essa instância precede, segue ou aparece na mesma posição na ordem de classificação que a Objectespecificada.
ConvertFromUtf32(Int32)	Converte o ponto de código Unicode especificado em uma cadeia de caracteres codificada em UTF-16.
ConvertToUtf32(Char, Char)	Converte o valor de um par alternativo codificado em UTF-16 em um ponto de código Unicode.
ConvertToUtf32(String, Int32)	Converte o valor de um caractere codificado utf-16 ou par alternativo 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 dessa 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 em uma cadeia de caracteres especificada em um número de ponto flutuante de precisão dupla.
GetTypeCode()	Retorna o TypeCode do tipo de valor Char.
GetUnicodeCategory(Char)	Categoriza um caractere Unicode especificado em um grupo identificado por um dos valores 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 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 minúsculas ASCII.
IsAsciiHexDigitUpper(Char)	Indica se um caractere é categorizado como um dígito hexadêmico de maiúsculas de 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 substituto 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 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 um 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 minúscula.
IsLowSurrogate(Char)	Indica se o objeto Char especificado é um substituto 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 alternativa.
IsSurrogate(String, Int32)	Indica se o caractere na posição especificada em uma cadeia de caracteres especificada tem uma unidade de código alternativa.
IsSurrogatePair(Char, Char)	Indica se os dois objetos Char especificados formam um par alternativo.
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 espaço em branco.
IsWhiteSpace(String, Int32)	Indica se o caractere na posição especificada em uma cadeia de caracteres especificada é categorizado como espaço 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 minúsculo.
ToLower(Char, CultureInfo)	Converte o valor de um caractere Unicode especificado em seu equivalente minúsculo usando informações de formatação específicas da cultura especificadas.
ToLowerInvariant(Char)	Converte o valor de um caractere Unicode em seu equivalente minúsculo usando as regras de maiúsculas e minúsculas da cultura invariável.
ToString()	Converte o valor dessa instância em sua representação de cadeia de caracteres equivalente.
ToString(Char)	Converte o caractere Unicode especificado em sua representação de cadeia de caracteres equivalente.
ToString(IFormatProvider)	Converte o valor dessa instância em sua representação de cadeia de caracteres equivalente usando as informações de formato específicas da cultura especificadas.
ToUpper(Char)	Converte o valor de um caractere Unicode em seu equivalente maiúsculo.
ToUpper(Char, CultureInfo)	Converte o valor de um caractere Unicode especificado em seu equivalente maiúsculo usando informações de formatação específicas da cultura especificadas.
ToUpperInvariant(Char)	Converte o valor de um caractere Unicode em seu equivalente maiúsculo usando as regras de maiú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 à 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 na 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 dois valores.
IBitwiseOperators<Char,Char,Char>.BitwiseOr(Char, Char)	Calcula o bit a bit ou de 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 essa conversão. Tentar fazer isso lança um InvalidCastException.
IConvertible.ToByte(IFormatProvider)	Para obter uma descrição desse membro, consulte ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Para obter uma descrição desse membro, consulte ToChar(IFormatProvider).
IConvertible.ToDateTime(IFormatProvider)	Observação Não há suporte para essa conversão. Tentar fazer isso lança um InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	Observação Não há suporte para essa conversão. Tentar fazer isso lança um InvalidCastException.
IConvertible.ToDouble(IFormatProvider)	Observação Não há suporte para essa conversão. Tentar fazer isso lança um InvalidCastException.
IConvertible.ToInt16(IFormatProvider)	Para obter uma descrição desse membro, consulte ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Para obter uma descrição desse membro, consulte ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Para obter uma descrição desse membro, consulte ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Para obter uma descrição desse membro, consulte ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Observação Não há suporte para essa conversão. Tentar fazer isso lança um InvalidCastException.
IConvertible.ToType(Type, IFormatProvider)	Para obter uma descrição desse membro, consulte ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Para obter uma descrição desse membro, consulte ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Para obter uma descrição desse membro, consulte ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Para obter uma descrição desse membro, consulte ToUInt64(IFormatProvider).
IDecrementOperators<Char>.CheckedDecrement(Char)	Decrementa um valor.
IDecrementOperators<Char>.Decrement(Char)	Decrementa 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 restante.
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 maior magnitude e retorna o outro valor se uma entrada é NaN.
INumberBase<Char>.MinMagnitude(Char, Char)	Compara dois valores com a computação menor.
INumberBase<Char>.MinMagnitudeNumber(Char, Char)	Compara dois valores com a computação que tem a menor magnitude e retorna o outro valor se uma entrada é NaN.
INumberBase<Char>.One	Obtém o valor 1 para o 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 o radix, ou 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 fiquem 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 todos os 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 para o 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 deixado por um determinado valor.
IShiftOperators<Char,Int32,Char>.RightShift(Char, Int32)	Desloca um valor para a direita por um determinado valor.
IShiftOperators<Char,Int32,Char>.UnsignedRightShift(Char, Int32)	Desloca um valor para a direita por 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 a diferença.
ISubtractionOperators<Char,Char,Char>.Subtraction(Char, Char)	Subtrai dois valores para calcular a 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 adição unária de um valor.
IUtf8SpanFormattable.TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tenta formatar o valor da instância atual como UTF-8 no intervalo de bytes fornecido.

Acesso thread-safe

Todos os membros desse tipo são thread safe. Os membros que parecem modificar o estado da instância retornam, na verdade, 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 contenha uma instância desse tipo devem ser protegidas por um bloqueio para garantir a segurança do thread.

Confira também

• IComparable
• IConvertible
• String