Char Estrutura

Definição

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

public value class char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
public value class char : IComparable, IComparable<char>, IConvertible, IEquatable<char>, ISpanFormattable
public value class char : IComparable<char>, IConvertible, IEquatable<char>, IParsable<char>, ISpanParsable<char>, System::Numerics::IAdditionOperators<char, char, char>, System::Numerics::IAdditiveIdentity<char, char>, System::Numerics::IBinaryInteger<char>, System::Numerics::IBinaryNumber<char>, System::Numerics::IBitwiseOperators<char, char, char>, System::Numerics::IComparisonOperators<char, char, bool>, System::Numerics::IDecrementOperators<char>, System::Numerics::IDivisionOperators<char, char, char>, System::Numerics::IEqualityOperators<char, char, bool>, System::Numerics::IIncrementOperators<char>, System::Numerics::IMinMaxValue<char>, System::Numerics::IModulusOperators<char, char, char>, System::Numerics::IMultiplicativeIdentity<char, char>, System::Numerics::IMultiplyOperators<char, char, char>, System::Numerics::INumber<char>, System::Numerics::INumberBase<char>, System::Numerics::IShiftOperators<char, int, char>, System::Numerics::ISubtractionOperators<char, char, char>, System::Numerics::IUnaryNegationOperators<char, char>, System::Numerics::IUnaryPlusOperators<char, char>, System::Numerics::IUnsignedNumber<char>
public value class char : IComparable<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, IConvertible
public value class char : IComparable, IComparable<char>, IEquatable<char>
public struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
public readonly struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
public readonly struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>, ISpanFormattable
public readonly struct Char : IComparable<char>, IConvertible, IEquatable<char>, IParsable<char>, ISpanParsable<char>, System.Numerics.IAdditionOperators<char,char,char>, System.Numerics.IAdditiveIdentity<char,char>, System.Numerics.IBinaryInteger<char>, System.Numerics.IBinaryNumber<char>, System.Numerics.IBitwiseOperators<char,char,char>, System.Numerics.IComparisonOperators<char,char,bool>, System.Numerics.IDecrementOperators<char>, System.Numerics.IDivisionOperators<char,char,char>, System.Numerics.IEqualityOperators<char,char,bool>, System.Numerics.IIncrementOperators<char>, System.Numerics.IMinMaxValue<char>, System.Numerics.IModulusOperators<char,char,char>, System.Numerics.IMultiplicativeIdentity<char,char>, System.Numerics.IMultiplyOperators<char,char,char>, System.Numerics.INumber<char>, System.Numerics.INumberBase<char>, System.Numerics.IShiftOperators<char,int,char>, System.Numerics.ISubtractionOperators<char,char,char>, System.Numerics.IUnaryNegationOperators<char,char>, System.Numerics.IUnaryPlusOperators<char,char>, System.Numerics.IUnsignedNumber<char>
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>
[System.Serializable]
public struct Char : IComparable, IConvertible
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Char : IComparable, IComparable<char>, IConvertible, IEquatable<char>
public struct Char : IComparable, IComparable<char>, IEquatable<char>
type char = struct
    interface IConvertible
type char = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable
type char = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<char>
    interface ISpanFormattable
    interface ISpanParsable<char>
    interface IAdditionOperators<char, char, char>
    interface IAdditiveIdentity<char, char>
    interface IBinaryInteger<char>
    interface IBinaryNumber<char>
    interface IBitwiseOperators<char, char, char>
    interface IComparisonOperators<char, char, bool>
    interface IEqualityOperators<char, char, bool>
    interface IDecrementOperators<char>
    interface IDivisionOperators<char, char, char>
    interface IIncrementOperators<char>
    interface IModulusOperators<char, char, char>
    interface IMultiplicativeIdentity<char, char>
    interface IMultiplyOperators<char, char, char>
    interface INumber<char>
    interface INumberBase<char>
    interface ISubtractionOperators<char, char, char>
    interface IUnaryNegationOperators<char, char>
    interface IUnaryPlusOperators<char, char>
    interface IShiftOperators<char, int, char>
    interface IMinMaxValue<char>
    interface IUnsignedNumber<char>
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>
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>
[<System.Serializable>]
type char = struct
    interface IConvertible
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type char = struct
    interface IConvertible
type char = struct
Public Structure Char
Implements IComparable, IComparable(Of Char), IConvertible, IEquatable(Of Char)
Public Structure Char
Implements IComparable, IComparable(Of Char), IConvertible, IEquatable(Of Char), ISpanFormattable
Public Structure Char
Implements IAdditionOperators(Of Char, Char, Char), IAdditiveIdentity(Of Char, Char), IBinaryInteger(Of Char), IBinaryNumber(Of Char), IBitwiseOperators(Of Char, Char, Char), IComparable(Of Char), IComparisonOperators(Of Char, Char, Boolean), IConvertible, IDecrementOperators(Of Char), IDivisionOperators(Of Char, Char, Char), IEqualityOperators(Of Char, Char, Boolean), IEquatable(Of Char), IIncrementOperators(Of Char), IMinMaxValue(Of Char), IModulusOperators(Of Char, Char, Char), IMultiplicativeIdentity(Of Char, Char), IMultiplyOperators(Of Char, Char, Char), INumber(Of Char), INumberBase(Of Char), IParsable(Of Char), IShiftOperators(Of Char, Integer, Char), ISpanParsable(Of Char), ISubtractionOperators(Of Char, Char, Char), IUnaryNegationOperators(Of Char, Char), IUnaryPlusOperators(Of Char, Char), IUnsignedNumber(Of Char)
Public Structure Char
Implements 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, IConvertible
Public Structure Char
Implements IComparable, IComparable(Of Char), IEquatable(Of Char)
Herança
Atributos
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 sobre a API Complementar para Char.

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

IComparable.CompareTo(Object)

Compara a instância atual com outro objeto do mesmo tipo e retorna um inteiro que indica se a instância atual precede, segue ou ocorre na mesma posição da ordem de classificação do outro objeto.

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.GetTypeCode()

Retorna o TypeCode para essa instância.

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.ToString(IFormatProvider)

Converte o valor dessa instância em uma cadeia de caracteres equivalente, usando as informações de formatação específicas da cultura especificadas.

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 for 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 todos os valores que ficam 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 ficam 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 estão 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 deixado 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.

IUtf8SpanFormattable.TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Tenta formatar o valor da instância atual como UTF-8 no intervalo de bytes fornecido.

Aplica-se a

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