Conversion boxing et unboxing (Guide de programmation C#)

  • Article

Mise à jour : Juillet 2008

La conversion boxing consiste à convertir un type valeur en type object ou bien en n'importe quel type interface implémenté par ce type valeur. Lorsque le CLR convertit un type valeur, il inclut la valeur dans un wrapper, à l'intérieur d'un System.Object, et la stocke sur le tas managé. La conversion unboxing extrait le type valeur à partir l'objet. Dans l'exemple suivant, la variable de type entier i est convertie (boxed) et assignée à l'objet o.

int i = 123;
object o = (object)i;  // boxing

L'objet o peut être ensuite unboxed et assigné à la variable entier i :

o = 123;
i = (int)o;  // unboxing

Performance

Par rapport aux assignations simples, les conversions boxing et unboxing sont des processus qui coûtent cher en calcul. Lorsqu'un type valeur est converti, un nouvel objet doit être alloué et construit. À un degré moindre, le cast requis pour la conversion unboxing coûte également cher en calcul. Pour plus d'informations, consultez Performances.

Conversion boxing

La conversion boxing est utilisée pour stocker des types valeur dans le tas rassemblé par garbage collection. Il s'agit d'une conversion implicite d'un type valeur en type object ou bien en n'importe quel type interface implémenté par ce type valeur. La conversion boxing d'un type valeur alloue une instance d'objet sur le tas et copie la valeur dans le nouvel objet.

Dans l'exemple suivant, une variable de type valeur est déclarée :

int i = 123;

L'instruction ci-dessous réalise implicitement une conversion boxing sur la variable i :

object o = i;  // Implicit boxing

Le résultat de cette instruction crée, sur la pile, un objet o qui fait référence à une valeur de type int sur le tas. Cette valeur est une copie de la valeur de type valeur qui a été assignée à la variable i. La différence entre les deux variables, i et o, est illustrée dans la figure ci-dessous.

Conversion boxing

Il est également possible, mais jamais obligatoire, d'effectuer une conversion boxing explicite comme dans l'exemple suivant :

int i = 123;
object o = (object)i;  // explicit boxing

Description

Cet exemple utilise une conversion boxing pour convertir une variable i (entier) en un objet o. Ensuite, la valeur 123 stockée dans la variable i est remplacée par la valeur 456. L'exemple montre que le type valeur d'origine et que l'objet boxed utilisent des emplacements de mémoire distincts et peuvent, par conséquent, stocker des valeurs différentes.

Exemple

class TestBoxing
{
    static void Main()
    {
        int i = 123;
        object o = i;  // Implicit boxing

        i = 456;  // Change the contents of i

        System.Console.WriteLine("The value-type value = {0}", i);
        System.Console.WriteLine("The object-type value = {0}", o);
    }
}
/* Output:
    The value-type value = 456
    The object-type value = 123
*/

L'exemple suivant montre un cas de conversion unboxing non valide et l'InvalidCastException qui en résulte. Avec try et catch, un message d'erreur est affiché lorsque l'erreur se produit.

class TestUnboxing
{
    static void Main()
    {
        int i = 123;
        object o = i;  // implicit boxing

        try
        {
            int j = (short)o;  // attempt to unbox

            System.Console.WriteLine("Unboxing OK.");
        }
        catch (System.InvalidCastException e)
        {
            System.Console.WriteLine("{0} Error: Incorrect unboxing.", e.Message);
        }
    }
}

Sortie de ce programme :

Specified cast is not valid. Error: Incorrect unboxing.

Si vous modifiez l'instruction :

int j = (short) o;

en :

int j = (int) o;

la conversion sera réalisée, avec le résultat suivant :

Unboxing OK.

Conversion unboxing

Unboxing est une conversion explicite du type object en un type valeur ou bien d'un type interface en un type valeur qui implémente l'interface. Une conversion unboxing comprend les étapes suivantes :

  • Vérification de l'instance de l'objet pour s'assurer qu'il s'agit bien d'une valeur convertie du type valeur spécifié.

  • Copie de la valeur de l'instance dans la variable de type valeur.

Les instructions suivantes expliquent les conversions boxing et unboxing :

int i = 123;      // a value type
object o = i;     // boxing
int j = (int)o;  // unboxing

Le résultat de ces instructions est illustré dans la figure ci-dessous.

Conversion unboxing

Pour que la conversion unboxing de types valeur réussisse au moment de l'exécution, l'élément qui est unboxed doit être une référence à un objet précédemment créé par boxing d'une instance de ce type valeur. Essayer de convertir (unbox) null ou une référence en un type valeur incompatible provoque un InvalidCastException.

Spécifications du langage C#

Pour plus d'informations, consultez les sections suivantes dans Spécifications du langage C#.

  • 4.3.1 Conversions boxing

Rubriques connexes

Pour plus d'informations

Spécifications du langage C#

Pour plus d'informations, consultez la section suivante dans Spécifications du langage C#.

  • 4.3 Conversion boxing et conversion unboxing

Voir aussi

Concepts

Guide de programmation C#

Historique des modifications

Date

Historique

Raison

Juillet 2008

Regroupement dans cette rubrique des rubriques sur la conversion boxing et la conversion unboxing, précédemment séparées

Résolution des bogues de contenu.