IConvertible Interface

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

Important

Cette API n’est pas conforme CLS.

Définit les méthodes qui convertissent la valeur de la référence d'implémentation ou du type valeur en un type Common Language Runtime possédant une valeur équivalente.

C#

[System.CLSCompliant(false)]
public interface IConvertible

C#

[System.CLSCompliant(false)]
[System.Runtime.InteropServices.ComVisible(true)]
public interface IConvertible

Dérivé

System.Boolean

System.Byte

System.Char

System.DateTime

System.DBNull

System.Decimal

System.Double

System.Enum

System.Int16

System.Int32

System.Int64

System.SByte

System.Single

System.String

System.UInt16

System.UInt32

System.UInt64

Attributs

CLSCompliantAttribute ComVisibleAttribute

Exemples

L’exemple de code suivant illustre une implémentation d’une IConvertible classe de nombre complexe, ce qui lui permet d’être casté en premier en tant que Double membre statique Convert sur celui-ci Double.

C#

using System;

namespace ConsoleApplication2
{

    /// Class that implements IConvertible
    class Complex : IConvertible
    {
        double	x;
        double	y;

        public Complex(double x, double y)
        {
            this.x = x;
            this.y = y;
        }

        public TypeCode GetTypeCode()
        {
            return TypeCode.Object;
        }

        bool IConvertible.ToBoolean(IFormatProvider provider)
        {
            if(	(x != 0.0) || (y != 0.0) )
                return true;
            else
                return false;
        }

        double GetDoubleValue()
        {
            return Math.Sqrt(x*x + y*y);
        }

        byte IConvertible.ToByte(IFormatProvider provider)
        {
            return Convert.ToByte(GetDoubleValue());
        }

        char IConvertible.ToChar(IFormatProvider provider)
        {
            return Convert.ToChar(GetDoubleValue());
        }

        DateTime IConvertible.ToDateTime(IFormatProvider provider)
        {
            return Convert.ToDateTime(GetDoubleValue());
        }

        decimal IConvertible.ToDecimal(IFormatProvider provider)
        {
            return Convert.ToDecimal(GetDoubleValue());
        }

        double IConvertible.ToDouble(IFormatProvider provider)
        {
            return GetDoubleValue();
        }

        short IConvertible.ToInt16(IFormatProvider provider)
        {
            return Convert.ToInt16(GetDoubleValue());
        }

        int IConvertible.ToInt32(IFormatProvider provider)
        {
            return Convert.ToInt32(GetDoubleValue());
        }

        long IConvertible.ToInt64(IFormatProvider provider)
        {
            return Convert.ToInt64(GetDoubleValue());
        }

        sbyte IConvertible.ToSByte(IFormatProvider provider)
        {
            return Convert.ToSByte(GetDoubleValue());
        }

        float IConvertible.ToSingle(IFormatProvider provider)
        {
            return Convert.ToSingle(GetDoubleValue());
        }

        string IConvertible.ToString(IFormatProvider provider)
        {
            return String.Format("({0}, {1})", x, y);
        }

        object IConvertible.ToType(Type conversionType, IFormatProvider provider)
        {
            return Convert.ChangeType(GetDoubleValue(),conversionType);
        }

        ushort IConvertible.ToUInt16(IFormatProvider provider)
        {
            return Convert.ToUInt16(GetDoubleValue());
        }

        uint IConvertible.ToUInt32(IFormatProvider provider)
        {
            return Convert.ToUInt32(GetDoubleValue());
        }

        ulong IConvertible.ToUInt64(IFormatProvider provider)
        {
            return Convert.ToUInt64(GetDoubleValue());
        }
    }

    /// <summary>
    /// Summary description for Class1.
    /// </summary>
    class Class1
    {
        static void Main(string[] args)
        {

            Complex		testComplex = new Complex(4,7);

            WriteObjectInfo(testComplex);
            WriteObjectInfo(Convert.ToBoolean(testComplex));
            WriteObjectInfo(Convert.ToDecimal(testComplex));
            WriteObjectInfo(Convert.ToString(testComplex));
        }

        static void WriteObjectInfo(object testObject)
        {
            TypeCode	typeCode = Type.GetTypeCode( testObject.GetType() );

            switch( typeCode )
            {
                case TypeCode.Boolean:
                    Console.WriteLine("Boolean: {0}", testObject);
                    break;

                case TypeCode.Double:
                    Console.WriteLine("Double: {0}", testObject);
                    break;
                                
                default:
                    Console.WriteLine("{0}: {1}", typeCode.ToString(), testObject);
                    break;
            }
        }
    }
}

Remarques

Cette interface fournit des méthodes pour convertir la valeur d’une instance d’un type d’implémentation en type Common Language Runtime qui a une valeur équivalente. Les types common language runtime sont Boolean, SByteInt16UInt32Int64Int32UInt64SingleUInt16ByteDecimalDateTimeDoubleCharet .String

S’il n’existe aucune conversion significative vers un type common language runtime, une implémentation de méthode d’interface particulière lève InvalidCastException. Par exemple, si cette interface est implémentée sur un type booléen, l’implémentation de la ToDateTime méthode lève une exception, car il n’y a pas d’équivalent significatif DateTime à un type booléen.

Le Common Language Runtime expose généralement l’interface IConvertible via la Convert classe. Le common language runtime utilise également l’interface IConvertible en interne, dans les implémentations d’interface explicites, pour simplifier le code utilisé pour prendre en charge les conversions dans la Convert classe et les types common language runtime de base.

En plus de l’interfaceIConvertible, le .NET Framework fournit des classes appelées convertisseurs de types pour convertir des types de données définis par l’utilisateur en d’autres types de données. Pour plus d’informations, consultez la rubrique Conversion de type généralisée .

Notes pour les responsables de l’implémentation

Si vous implémentez l’interface IConvertible , votre implémentation est appelée automatiquement par la ChangeType(Object, Type) méthode si le Object paramètre est une instance de votre type d’implémentation et que le Type paramètre est un type common language runtime.

La plupart des méthodes de conversion ont un paramètre de type IFormatProvider qui représente la culture actuelle (CurrentCulture) ou une culture spécifique. Pour la plupart, les IConvertible implémentations des types de base ignorent ce paramètre. Toutefois, vous pouvez choisir de l’utiliser dans votre code.

Méthodes

GetTypeCode()	Retourne le TypeCode de cette instance.
ToBoolean(IFormatProvider)	Convertit la valeur de cette instance en une valeur booléenne équivalente à l'aide des informations de mise en forme propres à la culture spécifiées.
ToByte(IFormatProvider)	Convertit la valeur de cette instance en un entier 8 bits non signé équivalent à l'aide des informations de mise en forme propres à la culture spécifiées.
ToChar(IFormatProvider)	Convertit la valeur de cette instance en un caractère Unicode équivalent à l'aide des informations de mise en forme propres à la culture spécifiées.
ToDateTime(IFormatProvider)	Convertit la valeur de cette instance en DateTime équivalent à l'aide des informations de mise en forme propres à la culture spécifiées.
ToDecimal(IFormatProvider)	Convertit la valeur de cette instance en nombre Decimal équivalent à l'aide des informations de mise en forme propres à la culture spécifiées.
ToDouble(IFormatProvider)	Convertit la valeur de cette instance en un nombre à virgule flottante double précision à l'aide des informations de mise en forme propres à la culture spécifiées.
ToInt16(IFormatProvider)	Convertit la valeur de cette instance en un entier 16 bits signé équivalent à l'aide des informations de mise en forme propres à la culture spécifiées.
ToInt32(IFormatProvider)	Convertit la valeur de cette instance en un entier 32 bits signé équivalent, à l’aide des informations de mise en forme propres à la culture spécifiées.
ToInt64(IFormatProvider)	Convertit la valeur de cette instance en un entier 64 bits signé équivalent, à l’aide des informations de mise en forme propres à la culture spécifiées.
ToSByte(IFormatProvider)	Convertit la valeur de cette instance en un entier 8 bits signé équivalent, à l’aide des informations de mise en forme propres à la culture spécifiées.
ToSingle(IFormatProvider)	Convertit la valeur de cette instance en un nombre à virgule flottante simple précision à l'aide des informations de mise en forme propres à la culture spécifiées.
ToString(IFormatProvider)	Convertit la valeur de cette instance en String équivalent à l'aide des informations de mise en forme propres à la culture spécifiées.
ToType(Type, IFormatProvider)	Convertit la valeur de cette instance en Object du Type spécifié possédant une valeur équivalente, à l'aide des informations de mise en forme propres à la culture spécifiées.
ToUInt16(IFormatProvider)	Convertit la valeur de cette instance en un entier 16 bits non signé équivalent, à l’aide des informations de mise en forme propres à la culture spécifiées.
ToUInt32(IFormatProvider)	Convertit la valeur de cette instance en un entier 32 bits non signé équivalent, à l’aide des informations de mise en forme propres à la culture spécifiées.
ToUInt64(IFormatProvider)	Convertit la valeur de cette instance en un entier 64 bits non signé équivalent, à l’aide des informations de mise en forme propres à la culture spécifiées.

S’applique à

Voir aussi

• Conversion de type dans le .NET Framework