Convert.ToChar Méthode

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Convertit une valeur spécifiée en caractères Unicode.

Surcharges

ToChar(String, IFormatProvider)	Convertit le premier caractère d'une chaîne spécifiée en caractère Unicode à l'aide des informations de mise en forme spécifiées propres à la culture.
ToChar(Object)	Convertit la valeur de l'objet spécifié en caractère Unicode.
ToChar(Object, IFormatProvider)	Convertit la valeur de l'objet spécifié en son caractère Unicode équivalent à l'aide des informations de mise en forme spécifiées propres à la culture.
ToChar(UInt64)	Convertit la valeur de l'entier non signé 64 bits spécifié en son caractère Unicode équivalent.
ToChar(UInt32)	Convertit la valeur de l'entier non signé 32 bits spécifié en son caractère Unicode équivalent.
ToChar(UInt16)	Convertit la valeur de l'entier non signé 16 bits spécifié en son caractère Unicode équivalent.
ToChar(String)	Convertit le premier caractère d'une chaîne spécifiée en caractère Unicode.
ToChar(Single)	L'appel de cette méthode lève toujours InvalidCastException.
ToChar(SByte)	Convertit la valeur de l'entier signé 8 bits spécifié en son caractère Unicode équivalent.
ToChar(Int64)	Convertit la valeur de l'entier signé 64 bits spécifié en son caractère Unicode équivalent.
ToChar(Int16)	Convertit la valeur de l'entier signé 16 bits spécifié en son caractère Unicode équivalent.
ToChar(Double)	L'appel de cette méthode lève toujours InvalidCastException.
ToChar(Decimal)	L'appel de cette méthode lève toujours InvalidCastException.
ToChar(DateTime)	L'appel de cette méthode lève toujours InvalidCastException.
ToChar(Char)	Retourne la valeur du caractère Unicode spécifiée. Aucune conversion n'est effectuée.
ToChar(Byte)	Convertit la valeur de l'entier non signé 8 bits spécifié en son caractère Unicode équivalent.
ToChar(Boolean)	L'appel de cette méthode lève toujours InvalidCastException.
ToChar(Int32)	Convertit la valeur de l'entier signé 32 bits spécifié en son caractère Unicode équivalent.

ToChar(String, IFormatProvider)

Source:

Convert.cs

Convertit le premier caractère d'une chaîne spécifiée en caractère Unicode à l'aide des informations de mise en forme spécifiées propres à la culture.

C#

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

Paramètres

value

String

Chaîne de longueur 1 ou null.

provider

IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture. Ce paramètre est ignoré.

Retours

Char

Caractère Unicode qui est équivalent au premier et unique caractère de value.

Exceptions

ArgumentNullException

value a la valeur null.

FormatException

La longueur de value n’est pas égale à 1.

Exemples

L’exemple suivant convertit une représentation sous forme de chaîne d’une Char valeur avec la méthode , à l’aide ToChar d’un IFormatProvider objet qui affiche le type du fournisseur de format pour lequel elle est appelée. L’exemple montre que le fournisseur de format n’est pas référencé.

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           $                $
*/

Remarques

value doit être une chaîne qui contient un caractère unique.

Si vous préférez ne pas gérer une exception si la conversion échoue, vous pouvez appeler la méthode à la Char.TryParse place. Elle retourne une Boolean valeur qui indique si la conversion a réussi ou échoué.

ToChar(Object)

Source:

Convert.cs

Convertit la valeur de l'objet spécifié en caractère Unicode.

C#

public static char ToChar (object? value);

Paramètres

value

Object

Objet qui implémente l'interface IConvertible.

Retours

Char

Caractère Unicode équivalent à value, ou Char.MinValue si value est null.

Exceptions

ArgumentNullException

value est une chaîne null.

InvalidCastException

value n’implémente pas l’interface IConvertible .

- ou -

La conversion de value en un Char n’est pas prise en charge.

OverflowException

value est inférieur à Char.MinValue ou supérieur à Char.MaxValue.

Exemples

L’exemple suivant tente de convertir chaque élément d’un tableau d’objets en valeur Char .

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.

Remarques

Si value n’est pas null, cette méthode encapsule un appel à l’implémentation IConvertible.ToChar du type sous-jacent de value.

ToChar(Object, IFormatProvider)

Source:

Convert.cs

Convertit la valeur de l'objet spécifié en son caractère Unicode équivalent à l'aide des informations de mise en forme spécifiées propres à la culture.

C#

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

Paramètres

value

Object

Objet qui implémente l'interface IConvertible.

provider

IFormatProvider

Objet qui fournit des informations de mise en forme propres à la culture.

Retours

Char

Caractère Unicode équivalent à value, ou Char.MinValue si value est null.

Exceptions

ArgumentNullException

value est une chaîne null.

InvalidCastException

value n’implémente pas l’interface IConvertible .

- ou -

La conversion de value en un Char n’est pas prise en charge.

OverflowException

value est inférieur à Char.MinValue ou supérieur à Char.MaxValue.

Exemples

L’exemple suivant définit une classe qui implémente IConvertible et une classe qui implémente IFormatProvider. Les objets de la classe qui implémente IConvertible contiennent un tableau de Double valeurs. Un objet de chaque classe est passé à la ToChar méthode . Cette méthode retourne un caractère dont la valeur Unicode est la moyenne du tableau de valeurs, à l’aide de Double l’objet qui implémente IFormatProvider pour déterminer comment calculer la moyenne.

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

Remarques

La valeur de retour est le résultat de l’appel de la IConvertible.ToChar méthode du type sous-jacent de value.

provider permet à l’utilisateur de spécifier des informations de conversion spécifiques à la culture sur le contenu de value. Les types de base ignorent provider; toutefois, le paramètre peut être utilisé si value est un type défini par l’utilisateur qui implémente l’interface IConvertible .

ToChar(UInt64)

Source:

Convert.cs

Important

Cette API n’est pas conforme CLS.

Convertit la valeur de l'entier non signé 64 bits spécifié en son caractère Unicode équivalent.

C#

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

Paramètres

value

UInt64

Entier non signé 64 bits à convertir.

Retours

Char

Caractère Unicode équivalent à value.

Attributs

CLSCompliantAttribute

Exceptions

OverflowException

value est supérieur à Char.MaxValue.

Exemples

L’exemple suivant convertit chaque élément d’un tableau d’entiers longs non signés en valeur Char .

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

Important

Cette API n’est pas conforme CLS.

Convertit la valeur de l'entier non signé 32 bits spécifié en son caractère Unicode équivalent.

C#

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

Paramètres

value

UInt32

Entier non signé 32 bits à convertir.

Retours

Char

Caractère Unicode équivalent à value.

Attributs

CLSCompliantAttribute

Exceptions

OverflowException

value est supérieur à Char.MaxValue.

Exemples

L’exemple suivant convertit chaque élément d’un tableau d’entiers non signés en valeur Char .

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

Important

Cette API n’est pas conforme CLS.

Convertit la valeur de l'entier non signé 16 bits spécifié en son caractère Unicode équivalent.

C#

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

Paramètres

value

UInt16

Entier non signé 16 bits à convertir.

Retours

Char

Caractère Unicode équivalent à value.

Attributs

CLSCompliantAttribute

Exemples

L’exemple suivant convertit chaque élément d’un tableau d’entiers 16 bits non signés en valeur Char .

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

Convertit le premier caractère d'une chaîne spécifiée en caractère Unicode.

C#

public static char ToChar (string value);

Paramètres

value

String

Chaîne de longueur 1.

Retours

Char

Caractère Unicode qui est équivalent au premier et unique caractère de value.

Exceptions

ArgumentNullException

value a la valeur null.

FormatException

La longueur de value n’est pas égale à 1.

Exemples

L’exemple suivant convertit chaque élément d’un tableau de chaînes en valeur Char .

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.

Remarques

value doit être une chaîne qui contient un caractère unique.

Si vous préférez ne pas gérer une exception si la conversion échoue, vous pouvez appeler la méthode à la Char.TryParse place. Elle retourne une Boolean valeur qui indique si la conversion a réussi ou échoué.

ToChar(Single)

Source:

Convert.cs

L'appel de cette méthode lève toujours InvalidCastException.

C#

public static char ToChar (float value);

Paramètres

value

Single

Nombre à virgule flottante simple précision à convertir.

Retours

Char

Cette conversion n'est pas prise en charge. Aucune valeur n’est retournée.

Exceptions

InvalidCastException

Cette conversion n'est pas prise en charge.

ToChar(SByte)

Source:

Convert.cs

Important

Cette API n’est pas conforme CLS.

Convertit la valeur de l'entier signé 8 bits spécifié en son caractère Unicode équivalent.

C#

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

Paramètres

value

SByte

Entier signé 8 bits à convertir.

Retours

Char

Caractère Unicode équivalent à value.

Attributs

CLSCompliantAttribute

Exceptions

OverflowException

value est inférieur à Char.MinValue.

Exemples

L’exemple suivant convertit un tableau d’octets signés en Char valeurs.

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

Convertit la valeur de l'entier signé 64 bits spécifié en son caractère Unicode équivalent.

C#

public static char ToChar (long value);

Paramètres

value

Int64

Entier signé 64 bits à convertir.

Retours

Char

Caractère Unicode équivalent à value.

Exceptions

OverflowException

value est inférieur à Char.MinValue ou supérieur à Char.MaxValue.

Exemples

L’exemple suivant tente de convertir un entier long en Char, et lève un en cas d’échec OverflowException .

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

Convertit la valeur de l'entier signé 16 bits spécifié en son caractère Unicode équivalent.

C#

public static char ToChar (short value);

Paramètres

value

Int16

Entier signé 16 bits à convertir.

Retours

Char

Caractère Unicode équivalent à value.

Exceptions

OverflowException

value est inférieur à Char.MinValue.

Exemples

L’exemple suivant convertit un tableau d’entiers 16 bits signés en Char valeurs.

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

L'appel de cette méthode lève toujours InvalidCastException.

C#

public static char ToChar (double value);

Paramètres

value

Double

Nombre à virgule flottante double précision à convertir.

Retours

Char

Cette conversion n'est pas prise en charge. Aucune valeur n’est retournée.

Exceptions

InvalidCastException

Cette conversion n'est pas prise en charge.

ToChar(Decimal)

Source:

Convert.cs

L'appel de cette méthode lève toujours InvalidCastException.

C#

public static char ToChar (decimal value);

Paramètres

value

Decimal

Nombre décimal à convertir.

Retours

Char

Cette conversion n'est pas prise en charge. Aucune valeur n’est retournée.

Exceptions

InvalidCastException

Cette conversion n'est pas prise en charge.

Exemples

L’exemple suivant tente de convertir un DecimalCharen , et lève InvalidCastException en cas d’échec.

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

L'appel de cette méthode lève toujours InvalidCastException.

C#

public static char ToChar (DateTime value);

Paramètres

value

DateTime

Valeur de date et heure à convertir.

Retours

Char

Cette conversion n'est pas prise en charge. Aucune valeur n’est retournée.

Exceptions

InvalidCastException

Cette conversion n'est pas prise en charge.

ToChar(Char)

Source:

Convert.cs

Retourne la valeur du caractère Unicode spécifiée. Aucune conversion n'est effectuée.

C#

public static char ToChar (char value);

Paramètres

value

Char

Caractère Unicode à retourner.

Retours

Char

value est retourné sans modification.

ToChar(Byte)

Source:

Convert.cs

Convertit la valeur de l'entier non signé 8 bits spécifié en son caractère Unicode équivalent.

C#

public static char ToChar (byte value);

Paramètres

value

Byte

Entier non signé 8 bits à convertir.

Retours

Char

Caractère Unicode équivalent à value.

Exemples

L’exemple suivant convertit un tableau d’octets non signés en Char valeurs.

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

L'appel de cette méthode lève toujours InvalidCastException.

C#

public static char ToChar (bool value);

Paramètres

value

Boolean

Valeur booléenne à convertir.

Retours

Char

Cette conversion n'est pas prise en charge. Aucune valeur n’est retournée.

Exceptions

InvalidCastException

Cette conversion n'est pas prise en charge.

ToChar(Int32)

Source:

Convert.cs

Convertit la valeur de l'entier signé 32 bits spécifié en son caractère Unicode équivalent.

C#

public static char ToChar (int value);

Paramètres

value

Int32

Entier signé 32 bits à convertir.

Retours

Char

Caractère Unicode équivalent à value.

Exceptions

OverflowException

value est inférieur à Char.MinValue ou supérieur à Char.MaxValue.

Exemples

L’exemple suivant convertit un tableau d’entiers signés en Char valeurs.

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.