Boxing et unboxing (Guide de programmation C#)Boxing and Unboxing (C# Programming Guide)

Le boxing est la conversion d’un type valeur en type object ou en un type interface implémenté par ce type valeur.Boxing is the process of converting a value type to the type object or to any interface type implemented by this value type. Quand le CLR exécute un boxing d’un type valeur, il wrappe la valeur dans une instance System.Object et la stocke sur le tas managé.When the CLR boxes a value type, it wraps the value inside a System.Object instance and stores it on the managed heap. L'unboxing extrait le type valeur de l'objet.Unboxing extracts the value type from the object. La conversion boxing est implicite ; la conversion unboxing est explicite.Boxing is implicit; unboxing is explicit. 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.The concept of boxing and unboxing underlies the C# unified view of the type system in which a value of any type can be treated as an object.

Dans l’exemple suivant, la variable de type entier i est convertie (boxed) et assignée à l’objet o.In the following example, the integer variable i is boxed and assigned to object o.

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

L’objet o peut ensuite être unboxed et assigné à la variable de type entier i :The object o can then be unboxed and assigned to integer variable i:

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

Les exemples suivants montrent comment le boxing est utilisé dans C#.The following examples illustrate how boxing is used in 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

PerformancesPerformance

Par rapport aux assignations simples, le boxing et l'unboxing sont des processus qui coûtent cher en calcul.In relation to simple assignments, boxing and unboxing are computationally expensive processes. Lorsqu'un type valeur est boxed, un nouvel objet doit être alloué et construit.When a value type is boxed, a new object must be allocated and constructed. À un degré moindre, le cast requis pour l'unboxing coûte également cher en calcul.To a lesser degree, the cast required for unboxing is also expensive computationally. Pour plus d’informations, consultez Performances.For more information, see Performance.

BoxingBoxing

Le boxing est utilisé pour stocker des types valeur dans le tas rassemblé par garbage collection.Boxing is used to store value types in the garbage-collected heap. Le boxing est une conversion implicite d’un type valeur en type object ou en un type interface implémenté par ce type valeur.Boxing is an implicit conversion of a value type to the type object or to any interface type implemented by this value type. Le boxing d'un type valeur alloue une instance d'objet sur le tas et copie la valeur dans le nouvel objet.Boxing a value type allocates an object instance on the heap and copies the value into the new object.

Dans l'exemple suivant, une variable de type valeur est déclarée :Consider the following declaration of a value-type variable:

int i = 123;

L'instruction ci-dessous réalise implicitement une opération de boxing sur la variable i :The following statement implicitly applies the boxing operation on the 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.The result of this statement is creating an object reference o, on the stack, that references a value of the type int, on the heap. Cette valeur est une copie de la valeur de type valeur qui a été assignée à la variable i.This value is a copy of the value-type value assigned to the variable i. La différence entre les deux variables, i et o, est illustrée dans l’image de conversion boxing ci-dessous :The difference between the two variables, i and o, is illustrated in the following image of boxing conversion:

Graphique illustrant la différence entre les variables i et o.

Il est également possible, mais jamais obligatoire, d'effectuer un boxing explicite comme dans l'exemple suivant :It is also possible to perform the boxing explicitly as in the following example, but explicit boxing is never required:

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

DescriptionDescription

Cet exemple utilise le boxing pour convertir une variable i (entier) en un objet o.This example converts an integer variable i to an object o by using boxing. Ensuite, la valeur i stockée dans la variable 123 est remplacée par la valeur 456.Then, the value stored in the variable i is changed from 123 to 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.The example shows that the original value type and the boxed object use separate memory locations, and therefore can store different values.

ExemplesExample

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 doesn't affect 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
*/

UnboxingUnboxing

L’unboxing est une conversion explicite du type object en un type valeur, ou d’un type interface en un type valeur qui implémente l’interface.Unboxing is an explicit conversion from the type object to a value type or from an interface type to a value type that implements the interface. Une opération d'unboxing comprend les étapes suivantes :An unboxing operation consists of:

  • 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é.Checking the object instance to make sure that it is a boxed value of the given value type.

  • Copie de la valeur de l'instance dans la variable de type valeur.Copying the value from the instance into the value-type variable.

Les instructions suivantes expliquent les opérations de boxing et d'unboxing :The following statements demonstrate both boxing and unboxing operations:

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

L’illustration suivante montre le résultat de ces instructions :The following figure demonstrates the result of the previous statements:

Image illustrant une 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.For the unboxing of value types to succeed at run time, the item being unboxed must be a reference to an object that was previously created by boxing an instance of that value type. La tentative d'extraction de null provoque un NullReferenceException.Attempting to unbox null causes a NullReferenceException. La tentative d'extraction d'une référence vers un type de valeur incompatible provoque un InvalidCastException.Attempting to unbox a reference to an incompatible value type causes an InvalidCastException.

ExemplesExample

L'exemple suivant montre un cas d'unboxing non valide et l'InvalidCastException qui en résulte.The following example demonstrates a case of invalid unboxing and the resulting InvalidCastException. Avec try et catch, un message d'erreur est affiché lorsque l'erreur se produit.Using try and catch, an error message is displayed when the error occurs.

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 :This program outputs:

Specified cast is not valid. Error: Incorrect unboxing.

Si vous modifiez l'instruction :If you change the statement:

int j = (short) o;  

en :to:

int j = (int) o;  

la conversion sera réalisée, avec le résultat suivant :the conversion will be performed, and you will get the output:

Unboxing OK.

Spécification du langage C#C# Language Specification

Pour plus d'informations, voir la spécification du langage C#.For more information, see the C# Language Specification. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.The language specification is the definitive source for C# syntax and usage.

Pour plus d'informations :For more information:

Voir aussiSee also