Convert.ToChar Método

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Convierte un valor especificado en un carácter Unicode.

Sobrecargas

ToChar(String, IFormatProvider)	Convierte el primer carácter de una cadena especificada en un carácter Unicode, usando la información de formato específica de la referencia cultural indicada.
ToChar(Object)	Convierte el valor del objeto especificado en un carácter Unicode.
ToChar(Object, IFormatProvider)	Convierte el valor del objeto especificado en su carácter Unicode equivalente, usando la información de formato específica de la referencia cultural indicada.
ToChar(UInt64)	Convierte el valor del entero de 64 bits sin signo especificado en el carácter Unicode equivalente.
ToChar(UInt32)	Convierte el valor del entero de 32 bits sin signo especificado en el carácter Unicode equivalente.
ToChar(UInt16)	Convierte el valor del entero de 16 bits sin signo especificado en el carácter Unicode equivalente.
ToChar(String)	Convierte el primer carácter de una cadena especificada en un carácter Unicode.
ToChar(Single)	Cuando se llama a este método, siempre se produce InvalidCastException.
ToChar(SByte)	Convierte el valor del entero de 8 bits con signo especificado en un carácter Unicode equivalente.
ToChar(Int64)	Convierte el valor del entero de 64 bits con signo especificado en un carácter Unicode equivalente.
ToChar(Int16)	Convierte el valor del entero de 16 bits con signo especificado en un carácter Unicode equivalente.
ToChar(Double)	Cuando se llama a este método, siempre se produce InvalidCastException.
ToChar(Decimal)	Cuando se llama a este método, siempre se produce InvalidCastException.
ToChar(DateTime)	Cuando se llama a este método, siempre se produce InvalidCastException.
ToChar(Char)	Devuelve el valor del carácter Unicode especificado; no se efectúa una conversión real.
ToChar(Byte)	Convierte el valor del entero de 8 bits sin signo especificado en el carácter Unicode equivalente.
ToChar(Boolean)	Cuando se llama a este método, siempre se produce InvalidCastException.
ToChar(Int32)	Convierte el valor del entero de 32 bits con signo especificado en un carácter Unicode equivalente.

ToChar(String, IFormatProvider)

Source:

Convert.cs

Convierte el primer carácter de una cadena especificada en un carácter Unicode, usando la información de formato específica de la referencia cultural indicada.

C#

public static char ToChar (string value, IFormatProvider? provider);

Parámetros

value

String

Una cadena de longitud 1 o null.

provider

IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural. Este parámetro se ignora.

Devoluciones

Char

Un carácter Unicode equivalente al primer y único carácter de value.

Excepciones

ArgumentNullException

value es null.

FormatException

La longitud de value no es 1.

Ejemplos

En el ejemplo siguiente se convierte una representación de cadena de un Char valor con el ToChar método , utilizando un IFormatProvider objeto que muestra el tipo del proveedor de formato para el que se llama. En el ejemplo se muestra que no se hace referencia al proveedor de formato.

C#

using System;
using System.Globalization;

public class DummyProvider : IFormatProvider
{
    // Normally, GetFormat returns an object of the requested type
    // (usually itself) if it is able; otherwise, it returns Nothing.
    public object GetFormat(Type argType)
    {
        // Here, GetFormat displays the name of argType, after removing
        // the namespace information. GetFormat always returns null.
        string argStr = argType.ToString( );
        if( argStr == "" )
            argStr = "Empty";
        argStr = argStr.Substring( argStr.LastIndexOf( '.' ) + 1 );

        Console.Write( "{0,-20}", argStr );
        return null;
    }
}

class ConvertNonNumericProviderDemo
{
    public static void Main( )
    {
        // Create an instance of IFormatProvider.
        DummyProvider provider = new DummyProvider( );
        string format   = "{0,-17}{1,-17}{2}";

        // Convert these values using DummyProvider.
        string Int32A   = "-252645135";
        string DoubleA  = "61680.3855";
        string DayTimeA = "2001/9/11 13:45";

        string BoolA    = "True";
        string StringA  = "Qwerty";
        string CharA    = "$";

        Console.WriteLine( "This example of selected " +
            "Convert.To<Type>( String, IFormatProvider ) \nmethods " +
            "generates the following output. The example displays " +
            "the \nprovider type if the IFormatProvider is called." );
        Console.WriteLine( "\nNote: For the " +
            "ToBoolean, ToString, and ToChar methods, the \n" +
            "IFormatProvider object is not referenced." );

        // The format provider is called for the following conversions.
        Console.WriteLine( );
        Console.WriteLine( format, "ToInt32", Int32A,
            Convert.ToInt32( Int32A, provider ) );
        Console.WriteLine( format, "ToDouble", DoubleA,
            Convert.ToDouble( DoubleA, provider ) );
        Console.WriteLine( format, "ToDateTime", DayTimeA,
            Convert.ToDateTime( DayTimeA, provider ) );

        // The format provider is not called for these conversions.
        Console.WriteLine( );
        Console.WriteLine( format, "ToBoolean", BoolA,
            Convert.ToBoolean( BoolA, provider ) );
        Console.WriteLine( format, "ToString", StringA,
            Convert.ToString( StringA, provider ) );
        Console.WriteLine( format, "ToChar", CharA,
            Convert.ToChar( CharA, provider ) );
    }
}

/*
This example of selected Convert.To<Type>( String, IFormatProvider )
methods generates the following output. The example displays the
provider type if the IFormatProvider is called.

Note: For the ToBoolean, ToString, and ToChar methods, the
IFormatProvider object is not referenced.

NumberFormatInfo    ToInt32          -252645135       -252645135
NumberFormatInfo    ToDouble         61680.3855       61680.3855
DateTimeFormatInfo  ToDateTime       2001/9/11 13:45  9/11/2001 1:45:00 PM

ToBoolean        True             True
ToString         Qwerty           Qwerty
ToChar           $                $
*/

Comentarios

value debe ser una cadena que contenga un solo carácter.

Si prefiere no controlar una excepción si se produce un error en la conversión, puede llamar al Char.TryParse método en su lugar. Devuelve un Boolean valor que indica si la conversión se realizó correctamente o no.

ToChar(Object)

Source:

Convert.cs

Convierte el valor del objeto especificado en un carácter Unicode.

C#

public static char ToChar (object? value);

Parámetros

value

Object

Objeto que implementa la interfaz IConvertible.

Devoluciones

Char

Carácter Unicode equivalente al valor o Char.MinValue si value es null.

Excepciones

ArgumentNullException

value es una cadena nula.

InvalidCastException

value no implementa la interfaz IConvertible.

O bien

No se admite la conversión de value a un Char.

OverflowException

value es menor que Char.MinValue o mayor que Char.MaxValue.

Ejemplos

En el ejemplo siguiente se intenta convertir cada elemento de una matriz de objetos en un Char valor .

C#

object[] values = { 'r', "s", "word", (byte) 83, 77, 109324, 335812911,
                    new DateTime(2009, 3, 10), (uint) 1934,
                    (sbyte) -17, 169.34, 175.6m, null };
char result;

foreach (object value in values)
{
   try {
      result = Convert.ToChar(value);
      Console.WriteLine("The {0} value {1} converts to {2}.",
                        value.GetType().Name, value, result);
   }
   catch (FormatException e) {
      Console.WriteLine(e.Message);
   }
   catch (InvalidCastException) {
      Console.WriteLine("Conversion of the {0} value {1} to a Char is not supported.",
                        value.GetType().Name, value);
   }
   catch (OverflowException) {
      Console.WriteLine("The {0} value {1} is outside the range of the Char data type.",
                        value.GetType().Name, value);
   }
   catch (NullReferenceException) {
      Console.WriteLine("Cannot convert a null reference to a Char.");
   }
}
// The example displays the following output:
//       The Char value r converts to r.
//       The String value s converts to s.
//       String must be exactly one character long.
//       The Byte value 83 converts to S.
//       The Int32 value 77 converts to M.
//       The Int32 value 109324 is outside the range of the Char data type.
//       The Int32 value 335812911 is outside the range of the Char data type.
//       Conversion of the DateTime value 3/10/2009 12:00:00 AM to a Char is not supported.
//       The UInt32 value 1934 converts to ?.
//       The SByte value -17 is outside the range of the Char data type.
//       Conversion of the Double value 169.34 to a Char is not supported.
//       Conversion of the Decimal value 175.6 to a Char is not supported.
//       Cannot convert a null reference to a Char.

Comentarios

Si value no nulles , este método encapsula una llamada a la IConvertible.ToChar implementación del tipo subyacente de value.

ToChar(Object, IFormatProvider)

Source:

Convert.cs

Convierte el valor del objeto especificado en su carácter Unicode equivalente, usando la información de formato específica de la referencia cultural indicada.

C#

public static char ToChar (object? value, IFormatProvider? provider);

Parámetros

value

Object

Objeto que implementa la interfaz IConvertible.

provider

IFormatProvider

Objeto que proporciona información de formato específica de la referencia cultural.

Devoluciones

Char

Carácter Unicode equivalente a value, o Char.MinValue si value es null.

Excepciones

ArgumentNullException

value es una cadena nula.

InvalidCastException

value no implementa la interfaz IConvertible.

O bien

No se admite la conversión de value a un Char.

OverflowException

value es menor que Char.MinValue o mayor que Char.MaxValue.

Ejemplos

En el ejemplo siguiente se define una clase que implementa IConvertible y una clase que implementa IFormatProvider. Los objetos de la clase que implementa IConvertible contienen una matriz de Double valores. Se pasa un objeto de cada clase al ToChar método . Este método devuelve un carácter cuyo valor Unicode es el promedio de la matriz de Double valores, utilizando el objeto que implementa IFormatProvider para determinar cómo calcular el promedio.

C#

using System;
using System.Collections;

// Define the types of averaging available in the class
// implementing IConvertible.
public enum AverageType : short
{
    None = 0,
    GeometricMean = 1,
    ArithmeticMean = 2,
    Median = 3
};

// Pass an instance of this class to methods that require an
// IFormatProvider. The class instance determines the type of
// average to calculate.
public class AverageInfo : IFormatProvider
{
    protected AverageType AvgType;

    // Specify the type of averaging in the constructor.
    public AverageInfo( AverageType avgType )
    {
        this.AvgType = avgType;
    }

    // This method returns a reference to the containing object
    // if an object of AverageInfo type is requested.
    public object GetFormat( Type argType )
    {
        if ( argType == typeof( AverageInfo ) )
            return this;
        else
            return null;
    }

    // Use this property to set or get the type of averaging.
    public AverageType TypeOfAverage
    {
        get { return this.AvgType; }
        set { this.AvgType = value; }
    }
}

// This class encapsulates an array of double values and implements
// the IConvertible interface. Most of the IConvertible methods
// return an average of the array elements in one of three types:
// arithmetic mean, geometric mean, or median.
public class DataSet : IConvertible
{
    protected ArrayList     data;
    protected AverageInfo   defaultProvider;

    // Construct the object and add an initial list of values.
    // Create a default format provider.
    public DataSet( params double[ ] values )
    {
        data = new ArrayList( values );
        defaultProvider =
            new AverageInfo( AverageType.ArithmeticMean );
    }

    // Add additional values with this method.
    public int Add( double value )
    {
        data.Add( value );
        return data.Count;
    }

    // Get, set, and add values with this indexer property.
    public double this[ int index ]
    {
        get
        {
            if( index >= 0 && index < data.Count )
                return (double)data[ index ];
            else
                throw new InvalidOperationException(
                    "[DataSet.get] Index out of range." );
        }
        set
        {
            if( index >= 0 && index < data.Count )
                data[ index ] = value;

            else if( index == data.Count )
                data.Add( value );
            else
                throw new InvalidOperationException(
                    "[DataSet.set] Index out of range." );
        }
    }

    // This property returns the number of elements in the object.
    public int Count
    {
        get { return data.Count; }
    }

    // This method calculates the average of the object's elements.
    protected double Average( AverageType avgType )
    {
        double  SumProd;

        if( data.Count == 0 )
            return 0.0;

        switch( avgType )
        {
            case AverageType.GeometricMean:

                SumProd = 1.0;
                for( int Index = 0; Index < data.Count; Index++ )
                    SumProd *= (double)data[ Index ];

                // This calculation will not fail with negative
                // elements.
                return Math.Sign( SumProd ) * Math.Pow(
                    Math.Abs( SumProd ), 1.0 / data.Count );

            case AverageType.ArithmeticMean:

                SumProd = 0.0;
                for( int Index = 0; Index < data.Count; Index++ )
                    SumProd += (double)data[ Index ];

                return SumProd / data.Count;

            case AverageType.Median:

                if( data.Count % 2 == 0 )
                    return ( (double)data[ data.Count / 2 ] +
                        (double)data[ data.Count / 2 - 1 ] ) / 2.0;
                else
                    return (double)data[ data.Count / 2 ];

            default:
                return 0.0;
        }
    }

    // Get the AverageInfo object from the caller's format provider,
    // or use the local default.
    protected AverageInfo GetAverageInfo( IFormatProvider provider )
    {
        AverageInfo avgInfo = null;

        if( provider != null )
            avgInfo = (AverageInfo)provider.GetFormat(
                typeof( AverageInfo ) );

        if ( avgInfo == null )
            return defaultProvider;
        else
            return avgInfo;
    }

    // Calculate the average and limit the range.
    protected double CalcNLimitAverage( double min, double max,
        IFormatProvider provider )
    {
        // Get the format provider and calculate the average.
        AverageInfo avgInfo = GetAverageInfo( provider );
        double avg = Average( avgInfo.TypeOfAverage );

        // Limit the range, based on the minimum and maximum values
        // for the type.
        return avg > max ? max : avg < min ? min : avg;
    }

    // The following elements are required by IConvertible.

    // None of these conversion functions throw exceptions. When
    // the data is out of range for the type, the appropriate
    // MinValue or MaxValue is used.
    public TypeCode GetTypeCode( )
    {
        return TypeCode.Object;
    }

    public bool ToBoolean( IFormatProvider provider )
    {
        // ToBoolean is false if the dataset is empty.
        if( data.Count <= 0 )
        {
            return false;
        }

        // For median averaging, ToBoolean is true if any
        // non-discarded elements are nonzero.
        else if( AverageType.Median ==
            GetAverageInfo( provider ).TypeOfAverage )
        {
            if (data.Count % 2 == 0 )
                return ( (double)data[ data.Count / 2 ] != 0.0 ||
                    (double)data[ data.Count / 2 - 1 ] != 0.0 );
            else
                return (double)data[ data.Count / 2 ] != 0.0;
        }

        // For arithmetic or geometric mean averaging, ToBoolean is
        // true if any element of the dataset is nonzero.
        else
        {
            for( int Index = 0; Index < data.Count; Index++ )
                if( (double)data[ Index ] != 0.0 )
                    return true;
            return false;
        }
    }

    public byte ToByte( IFormatProvider provider )
    {
        return Convert.ToByte( CalcNLimitAverage(
            Byte.MinValue, Byte.MaxValue, provider ) );
    }

    public char ToChar( IFormatProvider provider )
    {
        return Convert.ToChar( Convert.ToUInt16( CalcNLimitAverage(
            Char.MinValue, Char.MaxValue, provider ) ) );
    }

    // Convert to DateTime by adding the calculated average as
    // seconds to the current date and time. A valid DateTime is
    // always returned.
    public DateTime ToDateTime( IFormatProvider provider )
    {
        double seconds =
            Average( GetAverageInfo( provider ).TypeOfAverage );
        try
        {
            return DateTime.Now.AddSeconds( seconds );
        }
        catch( ArgumentOutOfRangeException )
        {
            return seconds < 0.0 ? DateTime.MinValue : DateTime.MaxValue;
        }
    }

    public decimal ToDecimal( IFormatProvider provider )
    {
        // The Double conversion rounds Decimal.MinValue and
        // Decimal.MaxValue to invalid Decimal values, so the
        // following limits must be used.
        return Convert.ToDecimal( CalcNLimitAverage(
            -79228162514264330000000000000.0,
            79228162514264330000000000000.0, provider ) );
    }

    public double ToDouble( IFormatProvider provider )
    {
        return Average( GetAverageInfo(provider).TypeOfAverage );
    }

    public short ToInt16( IFormatProvider provider )
    {
        return Convert.ToInt16( CalcNLimitAverage(
            Int16.MinValue, Int16.MaxValue, provider ) );
    }

    public int ToInt32( IFormatProvider provider )
    {
        return Convert.ToInt32( CalcNLimitAverage(
            Int32.MinValue, Int32.MaxValue, provider ) );
    }

    public long ToInt64( IFormatProvider provider )
    {
        // The Double conversion rounds Int64.MinValue and
        // Int64.MaxValue to invalid Int64 values, so the following
        // limits must be used.
        return Convert.ToInt64( CalcNLimitAverage(
            -9223372036854775000, 9223372036854775000, provider ) );
    }

    public SByte ToSByte( IFormatProvider provider )
    {
        return Convert.ToSByte( CalcNLimitAverage(
            SByte.MinValue, SByte.MaxValue, provider ) );
    }

    public float ToSingle( IFormatProvider provider )
    {
        return Convert.ToSingle( CalcNLimitAverage(
            Single.MinValue, Single.MaxValue, provider ) );
    }

    public UInt16 ToUInt16( IFormatProvider provider )
    {
        return Convert.ToUInt16( CalcNLimitAverage(
            UInt16.MinValue, UInt16.MaxValue, provider ) );
    }

    public UInt32 ToUInt32( IFormatProvider provider )
    {
        return Convert.ToUInt32( CalcNLimitAverage(
            UInt32.MinValue, UInt32.MaxValue, provider ) );
    }

    public UInt64 ToUInt64( IFormatProvider provider )
    {
        // The Double conversion rounds UInt64.MaxValue to an invalid
        // UInt64 value, so the following limit must be used.
        return Convert.ToUInt64( CalcNLimitAverage(
            0, 18446744073709550000.0, provider ) );
    }

    public object ToType( Type conversionType,
        IFormatProvider provider )
    {
        return Convert.ChangeType( Average(
            GetAverageInfo( provider ).TypeOfAverage ),
            conversionType );
    }

    public string ToString( IFormatProvider provider )
    {
        AverageType avgType = GetAverageInfo( provider ).TypeOfAverage;
        return String.Format( "( {0}: {1:G10} )", avgType,
            Average( avgType ) );
    }
}

class IConvertibleProviderDemo
{
    // Display a DataSet with three different format providers.
    public static void DisplayDataSet( DataSet ds )
    {
        string      fmt    = "{0,-12}{1,20}{2,20}{3,20}";
        AverageInfo median = new AverageInfo( AverageType.Median );
        AverageInfo geMean =
            new AverageInfo( AverageType.GeometricMean );

         // Display the dataset elements.
        if( ds.Count > 0 )
        {
            Console.Write( "\nDataSet: [{0}", ds[ 0 ] );
            for( int iX = 1; iX < ds.Count; iX++ )
                Console.Write( ", {0}", ds[ iX ] );
            Console.WriteLine( "]\n" );
        }

        Console.WriteLine( fmt, "Convert.", "Default",
            "Geometric Mean", "Median");
        Console.WriteLine( fmt, "--------", "-------",
            "--------------", "------");
        Console.WriteLine( fmt, "ToBoolean",
            Convert.ToBoolean( ds, null ),
            Convert.ToBoolean( ds, geMean ),
            Convert.ToBoolean( ds, median ) );
        Console.WriteLine( fmt, "ToByte",
            Convert.ToByte( ds, null ),
            Convert.ToByte( ds, geMean ),
            Convert.ToByte( ds, median ) );
        Console.WriteLine( fmt, "ToChar",
            Convert.ToChar( ds, null ),
            Convert.ToChar( ds, geMean ),
            Convert.ToChar( ds, median ) );
        Console.WriteLine( "{0,-12}{1,20:yyyy-MM-dd HH:mm:ss}" +
            "{2,20:yyyy-MM-dd HH:mm:ss}{3,20:yyyy-MM-dd HH:mm:ss}",
            "ToDateTime", Convert.ToDateTime( ds, null ),
            Convert.ToDateTime( ds, geMean ),
            Convert.ToDateTime( ds, median ) );
        Console.WriteLine( fmt, "ToDecimal",
            Convert.ToDecimal( ds, null ),
            Convert.ToDecimal( ds, geMean ),
            Convert.ToDecimal( ds, median ) );
        Console.WriteLine( fmt, "ToDouble",
            Convert.ToDouble( ds, null ),
            Convert.ToDouble( ds, geMean ),
            Convert.ToDouble( ds, median ) );
        Console.WriteLine( fmt, "ToInt16",
            Convert.ToInt16( ds, null ),
            Convert.ToInt16( ds, geMean ),
            Convert.ToInt16( ds, median ) );
        Console.WriteLine( fmt, "ToInt32",
            Convert.ToInt32( ds, null ),
            Convert.ToInt32( ds, geMean ),
            Convert.ToInt32( ds, median ) );
        Console.WriteLine( fmt, "ToInt64",
            Convert.ToInt64( ds, null ),
            Convert.ToInt64( ds, geMean ),
            Convert.ToInt64( ds, median ) );
        Console.WriteLine( fmt, "ToSByte",
            Convert.ToSByte( ds, null ),
            Convert.ToSByte( ds, geMean ),
            Convert.ToSByte( ds, median ) );
        Console.WriteLine( fmt, "ToSingle",
            Convert.ToSingle( ds, null ),
            Convert.ToSingle( ds, geMean ),
            Convert.ToSingle( ds, median ) );
        Console.WriteLine( fmt, "ToUInt16",
            Convert.ToUInt16( ds, null ),
            Convert.ToUInt16( ds, geMean ),
            Convert.ToUInt16( ds, median ) );
        Console.WriteLine( fmt, "ToUInt32",
            Convert.ToUInt32( ds, null ),
            Convert.ToUInt32( ds, geMean ),
            Convert.ToUInt32( ds, median ) );
        Console.WriteLine( fmt, "ToUInt64",
            Convert.ToUInt64( ds, null ),
            Convert.ToUInt64( ds, geMean ),
            Convert.ToUInt64( ds, median ) );
    }

    public static void Main( )
    {
        Console.WriteLine( "This example of " +
            "the Convert.To<Type>( object, IFormatProvider ) methods " +
            "\ngenerates the following output. The example " +
            "displays the values \nreturned by the methods, " +
            "using several IFormatProvider objects.\n" );

        DataSet ds1 = new DataSet(
            10.5, 22.2, 45.9, 88.7, 156.05, 297.6 );
        DisplayDataSet( ds1 );

        DataSet ds2 = new DataSet(
            359999.95, 425000, 499999.5, 775000, 1695000 );
        DisplayDataSet( ds2 );
    }
}

/*
This example of the Convert.To<Type>( object, IFormatProvider ) methods
generates the following output. The example displays the values
returned by the methods, using several IFormatProvider objects.

DataSet: [10.5, 22.2, 45.9, 88.7, 156.05, 297.6]

Convert.                 Default      Geometric Mean              Median
--------                 -------      --------------              ------
ToBoolean                   True                True                True
ToByte                       103                  59                  67
ToChar                         g                   ;                   C
ToDateTime   2003-05-13 15:04:12 2003-05-13 15:03:28 2003-05-13 15:03:35
ToDecimal       103.491666666667    59.4332135445164                67.3
ToDouble        103.491666666667    59.4332135445164                67.3
ToInt16                      103                  59                  67
ToInt32                      103                  59                  67
ToInt64                      103                  59                  67
ToSByte                      103                  59                  67
ToSingle                103.4917            59.43321                67.3
ToUInt16                     103                  59                  67
ToUInt32                     103                  59                  67
ToUInt64                     103                  59                  67

DataSet: [359999.95, 425000, 499999.5, 775000, 1695000]

Convert.                 Default      Geometric Mean              Median
--------                 -------      --------------              ------
ToBoolean                   True                True                True
ToByte                       255                 255                 255
ToChar                         ?                   ?                   ?
ToDateTime   2003-05-22 07:39:08 2003-05-20 22:28:45 2003-05-19 09:55:48
ToDecimal              750999.89    631577.237188435            499999.5
ToDouble               750999.89    631577.237188435            499999.5
ToInt16                    32767               32767               32767
ToInt32                   751000              631577              500000
ToInt64                   751000              631577              500000
ToSByte                      127                 127                 127
ToSingle                750999.9            631577.3            499999.5
ToUInt16                   65535               65535               65535
ToUInt32                  751000              631577              500000
ToUInt64                  751000              631577              500000
*/

Comentarios

El valor devuelto es el resultado de invocar el IConvertible.ToChar método del tipo subyacente de value.

provider permite al usuario especificar información de conversión específica de la referencia cultural sobre el contenido de value. Los tipos base omiten provider; sin embargo, el parámetro se puede usar si value es un tipo definido por el usuario que implementa la IConvertible interfaz .

ToChar(UInt64)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

Convierte el valor del entero de 64 bits sin signo especificado en el carácter Unicode equivalente.

C#

[System.CLSCompliant(false)]
public static char ToChar (ulong value);

Parámetros

value

UInt64

Entero de 64 bits sin signo que se va a convertir.

Devoluciones

Char

Un carácter Unicode equivalente a value.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

value es mayor que Char.MaxValue.

Ejemplos

En el ejemplo siguiente se convierte cada elemento de una matriz de enteros largos sin signo en un Char valor .

C#

ulong[] numbers = { UInt64.MinValue, 40, 160, 255, 1028,
                    2011, 30001, 207154, Int64.MaxValue };
char result;
foreach (ulong number in numbers)
{
   try {
      result = Convert.ToChar(number);
      Console.WriteLine("{0} converts to '{1}'.", number, result);
   }
   catch (OverflowException) {
      Console.WriteLine("{0} is outside the range of the Char data type.",
                        number);
   }
}
// The example displays the following output:
//       0 converts to ' '.
//       40 converts to '('.
//       160 converts to ' '.
//       255 converts to 'ÿ'.
//       1028 converts to 'Є'.
//       2011 converts to 'ߛ'.
//       30001 converts to '由'.
//       207154 is outside the range of the Char data type.
//       9223372036854775807 is outside the range of the Char data type.

ToChar(UInt32)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

Convierte el valor del entero de 32 bits sin signo especificado en el carácter Unicode equivalente.

C#

[System.CLSCompliant(false)]
public static char ToChar (uint value);

Parámetros

value

UInt32

Entero de 32 bits sin signo que se va a convertir.

Devoluciones

Char

Un carácter Unicode equivalente a value.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

value es mayor que Char.MaxValue.

Ejemplos

En el ejemplo siguiente se convierte cada elemento de una matriz de enteros sin signo en un Char valor .

C#

uint[] numbers = { UInt32.MinValue, 40, 160, 255, 1028,
                   2011, 30001, 207154, Int32.MaxValue };
char result;
foreach (uint number in numbers)
{
   try {
      result = Convert.ToChar(number);
      Console.WriteLine("{0} converts to '{1}'.", number, result);
   }
   catch (OverflowException) {
      Console.WriteLine("{0} is outside the range of the Char data type.",
                        number);
   }
}
// The example displays the following output:
//       0 converts to ' '.
//       40 converts to '('.
//       160 converts to ' '.
//       255 converts to 'ÿ'.
//       1028 converts to 'Є'.
//       2011 converts to 'ߛ'.
//       30001 converts to '由'.
//       207154 is outside the range of the Char data type.
//       2147483647 is outside the range of the Char data type.

ToChar(UInt16)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

Convierte el valor del entero de 16 bits sin signo especificado en el carácter Unicode equivalente.

C#

[System.CLSCompliant(false)]
public static char ToChar (ushort value);

Parámetros

value

UInt16

Entero de 16 bits sin signo que se va a convertir.

Devoluciones

Char

Un carácter Unicode equivalente a value.

Atributos

CLSCompliantAttribute

Ejemplos

En el ejemplo siguiente se convierte cada elemento de una matriz de enteros de 16 bits sin signo en un Char valor .

C#

ushort[] numbers = { UInt16.MinValue, 40, 160, 255, 1028,
                     2011, UInt16.MaxValue };
char result;
foreach (ushort number in numbers)
{
   result = Convert.ToChar(number);
   Console.WriteLine("{0} converts to '{1}'.", number, result);
}
// The example displays the following output:
//       0 converts to ' '.
//       40 converts to '('.
//       160 converts to ' '.
//       255 converts to 'ÿ'.
//       1028 converts to 'Є'.
//       2011 converts to 'ߛ'.
//       65535 converts to ''.

ToChar(String)

Source:

Convert.cs

Convierte el primer carácter de una cadena especificada en un carácter Unicode.

C#

public static char ToChar (string value);

Parámetros

value

String

Una cadena de longitud 1.

Devoluciones

Char

Un carácter Unicode equivalente al primer y único carácter de value.

Excepciones

ArgumentNullException

value es null.

FormatException

La longitud de value no es 1.

Ejemplos

En el ejemplo siguiente se convierte cada elemento de una matriz de cadenas en un Char valor .

C#

string nullString = null;
string[] strings = { "A", "This",  '\u0007'.ToString(), nullString };
char result;
foreach (string strng in strings)
{
   try {
      result = Convert.ToChar(strng);
      Console.WriteLine("'{0}' converts to '{1}'.", strng, result);
   }
   catch (FormatException)
   {
      Console.WriteLine("'{0}' is not in the correct format for conversion to a Char.",
                        strng);
   }
   catch (ArgumentNullException) {
      Console.WriteLine("A null string cannot be converted to a Char.");
   }
}
// The example displays the following output:
//       'A' converts to 'A'.
//       'This' is not in the correct format for conversion to a Char.
//       '       ' converts to ' '.
//       A null string cannot be converted to a Char.

Comentarios

value debe ser una cadena que contenga un solo carácter.

Si prefiere no controlar una excepción si se produce un error en la conversión, puede llamar al Char.TryParse método en su lugar. Devuelve un Boolean valor que indica si la conversión se realizó correctamente o no.

ToChar(Single)

Source:

Convert.cs

Cuando se llama a este método, siempre se produce InvalidCastException.

C#

public static char ToChar (float value);

Parámetros

value

Single

Número de punto flotante de precisión sencilla que se va a convertir.

Devoluciones

Char

No se admite esta conversión. No se devuelve ningún valor.

Excepciones

InvalidCastException

No se admite esta conversión.

ToChar(SByte)

Source:

Convert.cs

Importante

Esta API no es conforme a CLS.

Convierte el valor del entero de 8 bits con signo especificado en un carácter Unicode equivalente.

C#

[System.CLSCompliant(false)]
public static char ToChar (sbyte value);

Parámetros

value

SByte

Entero de 8 bits con signo que se va a convertir.

Devoluciones

Char

Un carácter Unicode equivalente a value.

Atributos

CLSCompliantAttribute

Excepciones

OverflowException

value es menor que Char.MinValue.

Ejemplos

En el ejemplo siguiente se convierte una matriz de bytes firmados en Char valores.

C#

sbyte[] numbers = { SByte.MinValue, -1, 40, 80, 120, SByte.MaxValue };
char result;
foreach (sbyte number in numbers)
{
   try {
      result = Convert.ToChar(number);
      Console.WriteLine("{0} converts to '{1}'.", number, result);
   }
   catch (OverflowException) {
      Console.WriteLine("{0} is outside the range of the Char data type.",
                        number);
   }
}
// The example displays the following output:
//       -128 is outside the range of the Char data type.
//       -1 is outside the range of the Char data type.
//       40 converts to '('.
//       80 converts to 'P'.
//       120 converts to 'x'.
//       127 converts to '⌂'.

ToChar(Int64)

Source:

Convert.cs

Convierte el valor del entero de 64 bits con signo especificado en un carácter Unicode equivalente.

C#

public static char ToChar (long value);

Parámetros

value

Int64

Entero de 64 bits con signo que se va a convertir.

Devoluciones

Char

Un carácter Unicode equivalente a value.

Excepciones

OverflowException

value es menor que Char.MinValue o mayor que Char.MaxValue.

Ejemplos

En el ejemplo siguiente se intenta convertir un entero Charlargo en y se produce un OverflowException error en .

C#

public void ConvertLongChar(long longVal) {

    char	charVal = 'a';

    try {
        charVal = System.Convert.ToChar(longVal);
        System.Console.WriteLine("{0} as a char is {1}",
            longVal, charVal);
    }
    catch (System.OverflowException) {
        System.Console.WriteLine(
            "Overflow in long-to-char conversion.");
    }
    
    // A conversion from Char to long cannot overflow.
    longVal = System.Convert.ToInt64(charVal);
    System.Console.WriteLine("{0} as an Int64 is {1}",
        charVal, longVal);
}

ToChar(Int16)

Source:

Convert.cs

Convierte el valor del entero de 16 bits con signo especificado en un carácter Unicode equivalente.

C#

public static char ToChar (short value);

Parámetros

value

Int16

Entero de 16 bits con signo que se va a convertir.

Devoluciones

Char

Un carácter Unicode equivalente a value.

Excepciones

OverflowException

value es menor que Char.MinValue.

Ejemplos

En el ejemplo siguiente se convierte una matriz de enteros de 16 bits con signo en Char valores.

C#

short[] numbers = { Int16.MinValue, 0, 40, 160, 255, 1028,
                    2011, Int16.MaxValue };
char result;
foreach (short number in numbers)
{
   try {
      result = Convert.ToChar(number);
      Console.WriteLine("{0} converts to '{1}'.", number, result);
   }
   catch (OverflowException) {
      Console.WriteLine("{0} is outside the range of the Char data type.",
                        number);
   }
}
// The example displays the following output:
//       -32768 is outside the range of the Char data type.
//       0 converts to ' '.
//       40 converts to '('.
//       160 converts to ' '.
//       255 converts to 'ÿ'.
//       1028 converts to 'Є'.
//       2011 converts to 'ߛ'.
//       32767 converts to '翿'.

ToChar(Double)

Source:

Convert.cs

Cuando se llama a este método, siempre se produce InvalidCastException.

C#

public static char ToChar (double value);

Parámetros

value

Double

Número de punto flotante de precisión doble que se va a convertir.

Devoluciones

Char

No se admite esta conversión. No se devuelve ningún valor.

Excepciones

InvalidCastException

No se admite esta conversión.

ToChar(Decimal)

Source:

Convert.cs

Cuando se llama a este método, siempre se produce InvalidCastException.

C#

public static char ToChar (decimal value);

Parámetros

value

Decimal

Número decimal que se va a convertir.

Devoluciones

Char

No se admite esta conversión. No se devuelve ningún valor.

Excepciones

InvalidCastException

No se admite esta conversión.

Ejemplos

En el ejemplo siguiente se intenta convertir en DecimalChary se produce InvalidCastException un error.

C#

public void ConvertCharDecimal(char charVal) {
    Decimal decimalVal = 0;
    
    // Char to decimal conversion is not supported and will always
    // throw an InvalidCastException.
    try {
        decimalVal = System.Convert.ToDecimal(charVal);
    }
    catch (System.InvalidCastException) {
        System.Console.WriteLine(
            "Char-to-Decimal conversion is not supported " +
            "by the .NET Framework.");
    }

    //Decimal to char conversion is also not supported.
    try {
        charVal = System.Convert.ToChar(decimalVal);
    }
    catch (System.InvalidCastException) {
        System.Console.WriteLine(
            "Decimal-to-Char conversion is not supported " +
            "by the .NET Framework.");
    }
}

ToChar(DateTime)

Source:

Convert.cs

Cuando se llama a este método, siempre se produce InvalidCastException.

C#

public static char ToChar (DateTime value);

Parámetros

value

DateTime

Valor de fecha y hora que se va a convertir.

Devoluciones

Char

No se admite esta conversión. No se devuelve ningún valor.

Excepciones

InvalidCastException

No se admite esta conversión.

ToChar(Char)

Source:

Convert.cs

Devuelve el valor del carácter Unicode especificado; no se efectúa una conversión real.

C#

public static char ToChar (char value);

Parámetros

value

Char

Carácter Unicode que se va a devolver.

Devoluciones

Char

value se devuelve sin cambios.

ToChar(Byte)

Source:

Convert.cs

Convierte el valor del entero de 8 bits sin signo especificado en el carácter Unicode equivalente.

C#

public static char ToChar (byte value);

Parámetros

value

Byte

Entero de 8 bits sin signo que se va a convertir.

Devoluciones

Char

Un carácter Unicode equivalente a value.

Ejemplos

En el ejemplo siguiente se convierte una matriz de bytes sin signo en Char valores.

C#

byte[] bytes = {Byte.MinValue, 40, 80, 120, 180, Byte.MaxValue};
char result;
foreach (byte number in bytes)
{
   result = Convert.ToChar(number);
   Console.WriteLine("{0} converts to '{1}'.", number, result);
}
// The example displays the following output:
//       0 converts to ' '.
//       40 converts to '('.
//       80 converts to 'P'.
//       120 converts to 'x'.
//       180 converts to '''.
//       255 converts to 'ÿ'.

ToChar(Boolean)

Source:

Convert.cs

Cuando se llama a este método, siempre se produce InvalidCastException.

C#

public static char ToChar (bool value);

Parámetros

value

Boolean

Valor booleano que se va a convertir.

Devoluciones

Char

No se admite esta conversión. No se devuelve ningún valor.

Excepciones

InvalidCastException

No se admite esta conversión.

ToChar(Int32)

Source:

Convert.cs

Convierte el valor del entero de 32 bits con signo especificado en un carácter Unicode equivalente.

C#

public static char ToChar (int value);

Parámetros

value

Int32

Entero de 32 bits con signo que se va a convertir.

Devoluciones

Char

Un carácter Unicode equivalente a value.

Excepciones

OverflowException

value es menor que Char.MinValue o mayor que Char.MaxValue.

Ejemplos

En el ejemplo siguiente se convierte una matriz de enteros Char con signo en valores.

C#

int[] numbers = { -1, 0, 40, 160, 255, 1028,
                  2011, 30001, 207154, Int32.MaxValue };
char result;
foreach (int number in numbers)
{
   try {
      result = Convert.ToChar(number);
      Console.WriteLine("{0} converts to '{1}'.", number, result);
   }
   catch (OverflowException) {
      Console.WriteLine("{0} is outside the range of the Char data type.",
                        number);
   }
}
//       -1 is outside the range of the Char data type.
//       0 converts to ' '.
//       40 converts to '('.
//       160 converts to ' '.
//       255 converts to 'ÿ'.
//       1028 converts to 'Є'.
//       2011 converts to 'ߛ'.
//       30001 converts to '由'.
//       207154 is outside the range of the Char data type.
//       2147483647 is outside the range of the Char data type.