Boxing et unboxing (Guide de programmation C#)

Le 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 exécute un boxing d'un type valeur, il inclut la valeur dans un wrapper, à l'intérieur d'un System.Object, et la stocke sur le tas managé. L'unboxing extrait le type valeur de l'objet. La conversion boxing est implicite ; la conversion unboxing est explicite. Le concept de boxing et de unboxing repose sur la vue unifiée par C# du système de type, dans lequel une valeur de n'importe quel type peut être traitée en tant qu'objet.

Dans l'exemple suivant, la variable de type entier i est convertie (boxed) et assignée à l'objet o.

int i = 123;
// The following line boxes i.
object o = i;  

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

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

Les exemples suivants montrent comment le boxing est utilisé dans C#.

// String.Concat example.
// String.Concat has many versions. Rest the mouse pointer on 
// Concat in the following statement to verify that the version
// that is used here takes three object arguments. Both 42 and
// true must be boxed.
Console.WriteLine(String.Concat("Answer", 42, true));


// List example.
// Create a list of objects to hold a heterogeneous collection 
// of elements.
List<object> mixedList = new List<object>();

// Add a string element to the list. 
mixedList.Add("First Group:");

// Add some integers to the list. 
for (int j = 1; j < 5; j++)
{
    // Rest the mouse pointer over j to verify that you are adding
    // an int to a list of objects. Each element j is boxed when 
    // you add j to mixedList.
    mixedList.Add(j);
}

// Add another string and more integers.
mixedList.Add("Second Group:");
for (int j = 5; j < 10; j++)
{
    mixedList.Add(j);
}

// Display the elements in the list. Declare the loop variable by 
// using var, so that the compiler assigns its type.
foreach (var item in mixedList)
{
    // Rest the mouse pointer over item to verify that the elements
    // of mixedList are objects.
    Console.WriteLine(item);
}

// The following loop sums the squares of the first group of boxed
// integers in mixedList. The list elements are objects, and cannot
// be multiplied or added to the sum until they are unboxed. The
// unboxing must be done explicitly.
var sum = 0;
for (var j = 1; j < 5; j++)
{
    // The following statement causes a compiler error: Operator 
    // '*' cannot be applied to operands of type 'object' and
    // 'object'. 
    //sum += mixedList[j] * mixedList[j]);

    // After the list elements are unboxed, the computation does 
    // not cause a compiler error.
    sum += (int)mixedList[j] * (int)mixedList[j];
}

// The sum displayed is 30, the sum of 1 + 4 + 9 + 16.
Console.WriteLine("Sum: " + sum);

// Output:
// Answer42True
// First Group:
// 1
// 2
// 3
// 4
// Second Group:
// 5
// 6
// 7
// 8
// 9
// Sum: 30

Performances

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

Boxing

Le boxing est utilisé pour stocker des types valeur dans le tas rassemblé par garbage collection. Le boxing est une conversion implicite d'un type valeur en type object ou bien en n'importe quel type interface implémenté par ce type valeur. Le 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 opération de boxing sur la variable i :

// Boxing copies the value of i into object o.
object o = i;  

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 un boxing explicite comme dans l'exemple suivant :

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

Description

Cet exemple utilise le 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;

        // Boxing copies the value of i into object o.
        object o = i;  

        // Change the value of i.
        i = 456;  

        // The change in i does not effect the value stored in o.
        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 d'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.

Unboxing

L'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 opération d'unboxing comprend les étapes suivantes :

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

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

Les instructions suivantes expliquent les opérations de boxing et d'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 l'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. La tentative d'extraction de null provoque un NullReferenceException. La tentative d'extraction d'une référence vers un type de valeur incompatible provoque un InvalidCastException.

Spécification du langage C#

Pour plus d'informations, consultez la Spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.

Rubriques connexes

Pour plus d'informations :

• Types référence

• Types valeur

Spécification du langage C#

Pour plus d'informations, consultez la Spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.

Voir aussi

Concepts

Guide de programmation C#

Historique des modifications

Date	Historique	Motif
Juillet 2010	A clarifié l'introduction et a ajouté des exemples.	Commentaires client.