Cet article a fait l'objet d'une traduction manuelle. Déplacez votre pointeur sur les phrases de l'article pour voir la version originale de ce texte.
Traduction
Source
Ce sujet n'a pas encore été évalué - Évaluez ce sujet

IConvertible, interface

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.

Cette API n'est pas conforme CLS. 

Espace de noms :  System
Assembly :  mscorlib (dans mscorlib.dll)
[ComVisibleAttribute(true)]
[CLSCompliantAttribute(false)]
public interface IConvertible

Le type IConvertible expose les membres suivants.

  Nom Description
Méthode publique Pris en charge par XNA Framework tyz9cd4z.PortableClassLibrary(fr-fr,VS.100).gif GetTypeCode Retourne le TypeCode de cette instance.
Méthode publique Pris en charge par XNA Framework tyz9cd4z.PortableClassLibrary(fr-fr,VS.100).gif ToBoolean 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.
Méthode publique Pris en charge par XNA Framework tyz9cd4z.PortableClassLibrary(fr-fr,VS.100).gif ToByte Convertit la valeur de cette instance en un entier non signé 8 bits équivalent à l'aide des informations de mise en forme propres à la culture spécifiées.
Méthode publique Pris en charge par XNA Framework tyz9cd4z.PortableClassLibrary(fr-fr,VS.100).gif ToChar 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.
Méthode publique Pris en charge par XNA Framework tyz9cd4z.PortableClassLibrary(fr-fr,VS.100).gif ToDateTime Convertit la valeur de cette instance en DateTime équivalent à l'aide des informations de mise en forme propres à la culture spécifiées.
Méthode publique Pris en charge par XNA Framework tyz9cd4z.PortableClassLibrary(fr-fr,VS.100).gif ToDecimal Convertit la valeur de cette instance en nombre Decimal équivalent à l'aide des informations de mise en forme propres à la culture spécifiées.
Méthode publique Pris en charge par XNA Framework tyz9cd4z.PortableClassLibrary(fr-fr,VS.100).gif ToDouble 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.
Méthode publique Pris en charge par XNA Framework tyz9cd4z.PortableClassLibrary(fr-fr,VS.100).gif ToInt16 Convertit la valeur de cette instance en un entier signé 16 bits équivalent à l'aide des informations de mise en forme propres à la culture spécifiées.
Méthode publique Pris en charge par XNA Framework tyz9cd4z.PortableClassLibrary(fr-fr,VS.100).gif ToInt32 Convertit la valeur de cette instance en un entier signé 32 bits équivalent à l'aide des informations de mise en forme propres à la culture spécifiées.
Méthode publique Pris en charge par XNA Framework tyz9cd4z.PortableClassLibrary(fr-fr,VS.100).gif ToInt64 Convertit la valeur de cette instance en un entier signé 64 bits équivalent à l'aide des informations de mise en forme propres à la culture spécifiées.
Méthode publique Pris en charge par XNA Framework tyz9cd4z.PortableClassLibrary(fr-fr,VS.100).gif ToSByte Convertit la valeur de cette instance en un entier signé 8 bits équivalent à l'aide des informations de mise en forme propres à la culture spécifiées.
Méthode publique Pris en charge par XNA Framework tyz9cd4z.PortableClassLibrary(fr-fr,VS.100).gif ToSingle 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.
Méthode publique Pris en charge par XNA Framework tyz9cd4z.PortableClassLibrary(fr-fr,VS.100).gif ToString Convertit la valeur de cette instance en String équivalent à l'aide des informations de mise en forme propres à la culture spécifiées.
Méthode publique Pris en charge par XNA Framework tyz9cd4z.PortableClassLibrary(fr-fr,VS.100).gif ToType 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.
Méthode publique Pris en charge par XNA Framework tyz9cd4z.PortableClassLibrary(fr-fr,VS.100).gif ToUInt16 Convertit la valeur de cette instance en un entier non signé 16 bits équivalent à l'aide des informations de mise en forme propres à la culture spécifiées.
Méthode publique Pris en charge par XNA Framework tyz9cd4z.PortableClassLibrary(fr-fr,VS.100).gif ToUInt32 Convertit la valeur de cette instance en un entier non signé 32 bits équivalent à l'aide des informations de mise en forme propres à la culture spécifiées.
Méthode publique Pris en charge par XNA Framework tyz9cd4z.PortableClassLibrary(fr-fr,VS.100).gif ToUInt64 Convertit la valeur de cette instance en un entier non signé 64 bits équivalent à l'aide des informations de mise en forme propres à la culture spécifiées.
Début

Cette interface fournit des méthodes permettant de convertir la valeur d'une instance d'un type d'implémentation en un type Common Language Runtime possédant une valeur équivalente. Les types Common Language Runtime sont les suivants : Boolean, SByte, Byte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, Double, Decimal, DateTime, Char et String.

S'il n'existe aucune conversion significative en un type Common Language Runtime, l'implémentation d'une 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 méthode ToDateTime lève une exception, car il n'existe aucun équivalent DateTime significatif pour un type booléen.

Le Common Language Runtime expose généralement l'interface IConvertible par l'intermédiaire de la classe Convert. Le Common Language Runtime utilise également l'interface IConvertible en interne, dans des implémentations d'interface explicites afin de simplifier le code employé pour la prise en charge des conversions dans la classe Convert et dans les types Common Language Runtime de base.

Outre l'interface IConvertible, le .NET Framework fournit des classes appelées convertisseurs de type pour la conversion de 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.

Remarques à l'attention des implémenteurs

Si vous implémentez l'interface IConvertible, votre implémentation sera appelée automatiquement par la méthode Convert.ChangeType si le paramètre Object est une instance de votre type d'implémentation et le paramètre Type est un type de Common Language Runtime.

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

L'exemple de code suivant illustre une implémentation de IConvertible pour une classe de nombres complexes, en lui permettant d'être d'abord casté en Double puis en appelant ensuite les membres Convert statiques sur Double.


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;
			}
		}
	}
}


.NET Framework

Pris en charge dans : 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Pris en charge dans : 4, 3.5 SP1

Pris en charge dans :

Windows 7, Windows Vista SP1 ou ultérieur, Windows XP SP3, Windows XP SP2 Édition x64, Windows Server 2008 (installation minimale non prise en charge), Windows Server 2008 R2 (installation minimale prise en charge avec SP1 ou version ultérieure), Windows Server 2003 SP2

Le .NET Framework ne prend pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.
Cela vous a-t-il été utile ?
(1500 caractères restants)
Contenu de la communauté Ajouter
Annotations FAQ