Char Estructura

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Source:

Char.cs

Representa un carácter como unidad 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)

Herencia

Object

ValueType

Char

Implementaciones

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>

Ejemplos

En el ejemplo de código siguiente se muestran algunos de los métodos de 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

Comentarios

Para obtener más información sobre esta API, consulte Comentarios complementarios de la API para Char.

Campos

MaxValue	Representa el mayor valor posible de un Char. Este campo es constante.
MinValue	Representa el menor valor posible de un Char. Este campo es constante.

Métodos

CompareTo(Char)	Compara esta instancia con un objeto Char especificado e indica si esta instancia precede o sigue al objeto Char especificado o aparece en la misma posición que él en el criterio de ordenación.
CompareTo(Object)	Compara esta instancia con un objeto Object especificado e indica si esta instancia precede o sigue al objeto especificado o aparece en la misma posición que él en el criterio de ordenación.
ConvertFromUtf32(Int32)	Convierte el punto de código Unicode especificado en una cadena codificada mediante UTF-16.
ConvertToUtf32(Char, Char)	Convierte el valor de un par suplente codificado mediante UTF-16 en un punto de código Unicode.
ConvertToUtf32(String, Int32)	Convierte el valor de un par suplente o carácter codificado mediante UTF-16 que está situado en una posición concreta de una cadena en un punto de código Unicode.
Equals(Char)	Devuelve un valor que indica si esta instancia es igual que el objeto Char especificado.
Equals(Object)	Devuelve un valor que indica si esta instancia es igual que un objeto especificado.
GetHashCode()	Devuelve el código hash de esta instancia.
GetNumericValue(Char)	Convierte el carácter Unicode numérico especificado en un número de punto flotante de precisión doble.
GetNumericValue(String, Int32)	Convierte el carácter Unicode numérico situado en la posición especificada de una cadena especificada en un número de punto flotante de precisión doble.
GetTypeCode()	Devuelve el TypeCode para el tipo de valor Char.
GetUnicodeCategory(Char)	Clasifica un carácter Unicode especificado dentro de un grupo identificado por uno de los valores de UnicodeCategory.
GetUnicodeCategory(String, Int32)	Clasifica el carácter que ocupa la posición especificada en una cadena especificada dentro de un grupo identificado por uno de los valores de UnicodeCategory.
IsAscii(Char)	Devuelve true si c es un carácter ASCII ([ U+0000..U+007F ]).
IsAsciiDigit(Char)	Indica si un carácter se clasifica como un dígito ASCII.
IsAsciiHexDigit(Char)	Indica si un carácter se clasifica como un dígito hexademical ASCII.
IsAsciiHexDigitLower(Char)	Indica si un carácter se clasifica como un dígito hexademical en minúsculas ASCII.
IsAsciiHexDigitUpper(Char)	Indica si un carácter se clasifica como un dígito hexademical de mayúsculas y minúsculas ASCII.
IsAsciiLetter(Char)	Indica si un carácter se clasifica como una letra ASCII.
IsAsciiLetterLower(Char)	Indica si un carácter se clasifica como una letra ASCII en minúsculas.
IsAsciiLetterOrDigit(Char)	Indica si un carácter se clasifica como una letra o un dígito ASCII.
IsAsciiLetterUpper(Char)	Indica si un carácter se clasifica como una letra ASCII mayúscula.
IsBetween(Char, Char, Char)	Indica si un carácter está dentro del intervalo inclusivo especificado.
IsControl(Char)	Indica si el carácter Unicode especificado se clasifica por categorías como un carácter de control.
IsControl(String, Int32)	Indica si el carácter que ocupa la posición especificada en una cadena especificada se clasifica por categorías como un carácter de control.
IsDigit(Char)	Indica si el carácter Unicode especificado se clasifica por categorías como un dígito decimal.
IsDigit(String, Int32)	Indica si el carácter que ocupa la posición especificada en una cadena especificada se clasifica por categorías como un dígito decimal.
IsHighSurrogate(Char)	Indica si el objeto Char especificado es un suplente alto.
IsHighSurrogate(String, Int32)	Indica si el objeto Char situado en la posición especificada de una cadena es un suplente alto.
IsLetter(Char)	Indica si el carácter Unicode especificado pertenece a alguna categoría de letras Unicode.
IsLetter(String, Int32)	Indica si el carácter que ocupa la posición especificada en una determinada cadena pertenece a alguna categoría de letras Unicode.
IsLetterOrDigit(Char)	Indica si el carácter Unicode especificado pertenece a alguna categoría de letras o dígitos decimales.
IsLetterOrDigit(String, Int32)	Indica si el carácter que ocupa la posición especificada en una cadena especificada pertenece a alguna categoría de letras o dígitos decimales.
IsLower(Char)	Indica si el carácter Unicode especificado se clasifica por categorías como una letra minúscula.
IsLower(String, Int32)	Indica si el carácter que ocupa la posición especificada en una cadena especificada se clasifica por categorías como una letra minúscula.
IsLowSurrogate(Char)	Indica si el objeto Char especificado es un suplente bajo.
IsLowSurrogate(String, Int32)	Indica si el objeto Char situado en la posición especificada de una cadena es un suplente bajo.
IsNumber(Char)	Indica si el carácter Unicode especificado se clasifica por categorías como un número.
IsNumber(String, Int32)	Indica si el carácter que ocupa la posición especificada en una cadena especificada se clasifica por categorías como un número.
IsPunctuation(Char)	Indica si el carácter Unicode especificado se clasifica por categorías como un signo de puntuación.
IsPunctuation(String, Int32)	Indica si el carácter que ocupa la posición especificada en una cadena especificada se clasifica por categorías como un signo de puntuación.
IsSeparator(Char)	Indica si el carácter Unicode especificado se clasifica por categorías como un carácter separador.
IsSeparator(String, Int32)	Indica si el carácter que ocupa la posición especificada en una cadena especificada se clasifica por categorías como un carácter separador.
IsSurrogate(Char)	Indica si el carácter especificado tiene una unidad de código suplente.
IsSurrogate(String, Int32)	Indica si el carácter situado en la posición especificada de la cadena especificada tiene una unidad de código suplente.
IsSurrogatePair(Char, Char)	Indica si los dos objetos Char especificados forman un par suplente.
IsSurrogatePair(String, Int32)	Indica si dos objetos Char adyacentes en la posición especificada de una cadena forman un par suplente.
IsSymbol(Char)	Indica si el carácter Unicode especificado se clasifica por categorías como un carácter de símbolo.
IsSymbol(String, Int32)	Indica si el carácter que ocupa la posición especificada en una cadena especificada se clasifica por categorías como un carácter de símbolo.
IsUpper(Char)	Indica si el carácter Unicode especificado se clasifica por categorías como una letra mayúscula.
IsUpper(String, Int32)	Indica si el carácter que ocupa la posición especificada en una cadena especificada se clasifica por categorías como una letra mayúscula.
IsWhiteSpace(Char)	Indica si el carácter Unicode especificado se clasifica por categorías como un espacio en blanco.
IsWhiteSpace(String, Int32)	Indica si el carácter que ocupa la posición especificada en una cadena especificada se clasifica por categorías como un espacio en blanco.
Parse(String)	Convierte el valor de la cadena especificada en el carácter Unicode equivalente.
ToLower(Char)	Convierte el valor de un carácter Unicode en un carácter equivalente, pero en minúsculas.
ToLower(Char, CultureInfo)	Convierte el valor de un carácter Unicode especificado en un carácter equivalente pero en minúsculas mediante la información de formato específica de la referencia cultural especificada.
ToLowerInvariant(Char)	Convierte el valor de un carácter Unicode en su equivalente en minúsculas utilizando las reglas sobre mayúsculas y minúsculas de la referencia cultural de todos los idiomas.
ToString()	Convierte el valor de esta instancia en la representación de cadena equivalente.
ToString(Char)	Convierte el carácter Unicode especificado en la representación de cadena equivalente.
ToString(IFormatProvider)	Convierte el valor de esta instancia en la representación de cadena equivalente mediante la información de formato específica de la referencia cultural especificada.
ToUpper(Char)	Convierte el valor de un carácter Unicode en un carácter equivalente, pero en mayúsculas.
ToUpper(Char, CultureInfo)	Convierte el valor de un carácter Unicode especificado en el carácter equivalente pero en mayúsculas mediante la información de formato específica de la referencia cultural especificada.
ToUpperInvariant(Char)	Convierte el valor de un carácter Unicode en su equivalente en mayúsculas utilizando las reglas sobre mayúsculas y minúsculas de la referencia cultural de todos los idiomas.
TryParse(String, Char)	Convierte el valor de la cadena especificada en el carácter Unicode equivalente. Un código devuelto indica si la conversión fue correcta o no.

Implementaciones de interfaz explícitas

IAdditionOperators<Char,Char,Char>.Addition(Char, Char)	Agrega dos valores juntos para calcular su suma.
IAdditionOperators<Char,Char,Char>.CheckedAddition(Char, Char)	Agrega dos valores juntos para calcular su suma.
IAdditiveIdentity<Char,Char>.AdditiveIdentity	Obtiene la identidad de suma del tipo actual.
IBinaryInteger<Char>.GetByteCount()	Obtiene el número de bytes que se escribirán como parte de TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<Char>.GetShortestBitLength()	Obtiene la longitud, en bits, de la representación complementaria de dos más corta del valor actual.
IBinaryInteger<Char>.LeadingZeroCount(Char)	Calcula el número de bits cero iniciales en un valor.
IBinaryInteger<Char>.PopCount(Char)	Calcula el número de bits establecidos en un valor.
IBinaryInteger<Char>.RotateLeft(Char, Int32)	Gira un valor a la izquierda por una cantidad determinada.
IBinaryInteger<Char>.RotateRight(Char, Int32)	Gira un valor a la derecha por una cantidad determinada.
IBinaryInteger<Char>.TrailingZeroCount(Char)	Calcula el número de bits cero finales en un valor.
IBinaryInteger<Char>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Char)	Representa un carácter como unidad de código UTF-16.
IBinaryInteger<Char>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Char)	Representa un carácter como unidad de código UTF-16.
IBinaryInteger<Char>.TryWriteBigEndian(Span<Byte>, Int32)	Intenta escribir el valor actual, en formato big-endian, en un intervalo determinado.
IBinaryInteger<Char>.TryWriteLittleEndian(Span<Byte>, Int32)	Intenta escribir el valor actual, en formato little-endian, en un intervalo determinado.
IBinaryNumber<Char>.AllBitsSet	Obtiene una instancia del tipo binario en el que se establecen todos los bits.
IBinaryNumber<Char>.IsPow2(Char)	Determina si un valor es una potencia de dos.
IBinaryNumber<Char>.Log2(Char)	Calcula el registro2 de un valor.
IBitwiseOperators<Char,Char,Char>.BitwiseAnd(Char, Char)	Calcula los valores bit a bit y de dos valores.
IBitwiseOperators<Char,Char,Char>.BitwiseOr(Char, Char)	Calcula el bit a bit o de dos valores.
IBitwiseOperators<Char,Char,Char>.ExclusiveOr(Char, Char)	Calcula el valor exclusivo o de dos valores.
IBitwiseOperators<Char,Char,Char>.OnesComplement(Char)	Calcula la representación ones-complement de un valor determinado.
IComparisonOperators<Char,Char,Boolean>.GreaterThan(Char, Char)	Compara dos valores para determinar cuál es mayor.
IComparisonOperators<Char,Char,Boolean>.GreaterThanOrEqual(Char, Char)	Compara dos valores para determinar cuál es mayor o igual.
IComparisonOperators<Char,Char,Boolean>.LessThan(Char, Char)	Compara dos valores para determinar cuál es menor.
IComparisonOperators<Char,Char,Boolean>.LessThanOrEqual(Char, Char)	Compara dos valores para determinar cuál es menor o igual.
IConvertible.ToBoolean(IFormatProvider)	Nota No se admite esta conversión. Si se intenta, se produce una excepción InvalidCastException.
IConvertible.ToByte(IFormatProvider)	Para obtener una descripción de este miembro, vea ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Para obtener una descripción de este miembro, vea ToChar(IFormatProvider).
IConvertible.ToDateTime(IFormatProvider)	Nota No se admite esta conversión. Si se intenta, se produce una excepción InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	Nota No se admite esta conversión. Si se intenta, se produce una excepción InvalidCastException.
IConvertible.ToDouble(IFormatProvider)	Nota No se admite esta conversión. Si se intenta, se produce una excepción InvalidCastException.
IConvertible.ToInt16(IFormatProvider)	Para obtener una descripción de este miembro, vea ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Para obtener una descripción de este miembro, vea ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Para obtener una descripción de este miembro, vea ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Para obtener una descripción de este miembro, vea ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Nota No se admite esta conversión. Si se intenta, se produce una excepción InvalidCastException.
IConvertible.ToType(Type, IFormatProvider)	Para obtener una descripción de este miembro, vea ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Para obtener una descripción de este miembro, vea ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Para obtener una descripción de este miembro, vea ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Para obtener una descripción de este miembro, vea ToUInt64(IFormatProvider).
IDecrementOperators<Char>.CheckedDecrement(Char)	Disminuye un valor.
IDecrementOperators<Char>.Decrement(Char)	Disminuye un valor.
IDivisionOperators<Char,Char,Char>.Division(Char, Char)	Divide un valor por otro para calcular su cociente.
IEqualityOperators<Char,Char,Boolean>.Equality(Char, Char)	Compara dos valores para determinar la igualdad.
IEqualityOperators<Char,Char,Boolean>.Inequality(Char, Char)	Compara dos valores para determinar la desigualdad.
IFormattable.ToString(String, IFormatProvider)	Da formato al valor de la instancia actual usando el formato especificado.
IIncrementOperators<Char>.CheckedIncrement(Char)	Incrementa un valor.
IIncrementOperators<Char>.Increment(Char)	Incrementa un valor.
IMinMaxValue<Char>.MaxValue	Obtiene el valor máximo del tipo actual.
IMinMaxValue<Char>.MinValue	Obtiene el valor mínimo del tipo actual.
IModulusOperators<Char,Char,Char>.Modulus(Char, Char)	Divide dos valores juntos para calcular su módulo o resto.
IMultiplicativeIdentity<Char,Char>.MultiplicativeIdentity	Obtiene la identidad multiplicativa del tipo actual.
IMultiplyOperators<Char,Char,Char>.CheckedMultiply(Char, Char)	Multiplica dos valores juntos para calcular su producto.
IMultiplyOperators<Char,Char,Char>.Multiply(Char, Char)	Multiplica dos valores juntos para calcular su producto.
INumberBase<Char>.Abs(Char)	Calcula el valor absoluto de un valor.
INumberBase<Char>.IsCanonical(Char)	Determina si un valor está en su representación canónica.
INumberBase<Char>.IsComplexNumber(Char)	Determina si un valor representa un número complejo.
INumberBase<Char>.IsEvenInteger(Char)	Determina si un valor representa un número entero par.
INumberBase<Char>.IsFinite(Char)	Determina si un valor es finito.
INumberBase<Char>.IsImaginaryNumber(Char)	Determina si un valor representa un número imaginario puro.
INumberBase<Char>.IsInfinity(Char)	Determina si un valor es infinito.
INumberBase<Char>.IsInteger(Char)	Determina si un valor representa un número entero.
INumberBase<Char>.IsNaN(Char)	Determina si un valor es NaN.
INumberBase<Char>.IsNegative(Char)	Determina si un valor es negativo.
INumberBase<Char>.IsNegativeInfinity(Char)	Determina si un valor es infinito negativo.
INumberBase<Char>.IsNormal(Char)	Determina si un valor es normal.
INumberBase<Char>.IsOddInteger(Char)	Determina si un valor representa un número entero impar.
INumberBase<Char>.IsPositive(Char)	Determina si un valor es positivo.
INumberBase<Char>.IsPositiveInfinity(Char)	Determina si un valor es infinito positivo.
INumberBase<Char>.IsRealNumber(Char)	Determina si un valor representa un número real.
INumberBase<Char>.IsSubnormal(Char)	Determina si un valor es subnormal.
INumberBase<Char>.IsZero(Char)	Determina si un valor es cero.
INumberBase<Char>.MaxMagnitude(Char, Char)	Compara dos valores con el proceso, que es mayor.
INumberBase<Char>.MaxMagnitudeNumber(Char, Char)	Compara dos valores con el proceso que tiene la mayor magnitud y devuelve el otro valor si una entrada es NaN.
INumberBase<Char>.MinMagnitude(Char, Char)	Compara dos valores con el proceso, que es menor.
INumberBase<Char>.MinMagnitudeNumber(Char, Char)	Compara dos valores con el proceso que tiene la magnitud menor y devuelve el otro valor si una entrada es NaN.
INumberBase<Char>.One	Obtiene el valor 1 del tipo.
INumberBase<Char>.Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Analiza un intervalo de caracteres en un valor.
INumberBase<Char>.Parse(String, NumberStyles, IFormatProvider)	Analiza una cadena en un valor.
INumberBase<Char>.Radix	Obtiene la raíz, o base, para el tipo.
INumberBase<Char>.TryConvertFromChecked<TOther>(TOther, Char)	Representa un carácter como unidad de código UTF-16.
INumberBase<Char>.TryConvertFromSaturating<TOther>(TOther, Char)	Representa un carácter como unidad de código UTF-16.
INumberBase<Char>.TryConvertFromTruncating<TOther>(TOther, Char)	Representa un carácter como unidad de código UTF-16.
INumberBase<Char>.TryConvertToChecked<TOther>(Char, TOther)	Intenta convertir una instancia del tipo actual en otro tipo, iniciando una excepción de desbordamiento para los valores que se encuentran fuera del intervalo representable del tipo actual.
INumberBase<Char>.TryConvertToSaturating<TOther>(Char, TOther)	Intenta convertir una instancia del tipo actual en otro tipo, saturando los valores que se encuentran fuera del intervalo representable del tipo actual.
INumberBase<Char>.TryConvertToTruncating<TOther>(Char, TOther)	Intenta convertir una instancia del tipo actual en otro tipo, truncando los valores que se encuentran fuera del intervalo representable del tipo actual.
INumberBase<Char>.TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Char)	Representa un carácter como unidad de código UTF-16.
INumberBase<Char>.TryParse(String, NumberStyles, IFormatProvider, Char)	Representa un carácter como unidad de código UTF-16.
INumberBase<Char>.Zero	Obtiene el valor 0 del tipo.
IParsable<Char>.Parse(String, IFormatProvider)	Analiza una cadena en un valor.
IParsable<Char>.TryParse(String, IFormatProvider, Char)	Representa un carácter como unidad de código UTF-16.
IShiftOperators<Char,Int32,Char>.LeftShift(Char, Int32)	Desplaza un valor a la izquierda por una cantidad determinada.
IShiftOperators<Char,Int32,Char>.RightShift(Char, Int32)	Desplaza un valor a la derecha por una cantidad determinada.
IShiftOperators<Char,Int32,Char>.UnsignedRightShift(Char, Int32)	Desplaza un valor a la derecha por una cantidad determinada.
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Intenta dar formato al valor de la instancia actual en el intervalo de caracteres proporcionado.
ISpanParsable<Char>.Parse(ReadOnlySpan<Char>, IFormatProvider)	Analiza un intervalo de caracteres en un valor.
ISpanParsable<Char>.TryParse(ReadOnlySpan<Char>, IFormatProvider, Char)	Representa un carácter como unidad de código UTF-16.
ISubtractionOperators<Char,Char,Char>.CheckedSubtraction(Char, Char)	Resta dos valores para calcular su diferencia.
ISubtractionOperators<Char,Char,Char>.Subtraction(Char, Char)	Resta dos valores para calcular su diferencia.
IUnaryNegationOperators<Char,Char>.CheckedUnaryNegation(Char)	Calcula la negación unaria comprobada de un valor.
IUnaryNegationOperators<Char,Char>.UnaryNegation(Char)	Calcula la negación unaria de un valor.
IUnaryPlusOperators<Char,Char>.UnaryPlus(Char)	Calcula la unaria más de un valor.
IUtf8SpanFormattable.TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Intenta dar formato al valor de la instancia actual como UTF-8 en el intervalo de bytes proporcionado.

Seguridad para subprocesos

Todos los miembros de este tipo son seguros para subprocesos. Los miembros que parecen modificar el estado de la instancia devuelven realmente una nueva instancia inicializada con el nuevo valor. Al igual que con cualquier otro tipo, la lectura y escritura en una variable compartida que contiene una instancia de este tipo deben estar protegidas por un bloqueo para garantizar la seguridad de los subprocesos.

Consulte también

• IComparable
• IConvertible
• String