Boxing und Unboxing (C#-Programmierhandbuch)Boxing and Unboxing (C# Programming Guide)

Beim Boxing handelt es sich um die Konvertierung eines Werttyps in den Typ object oder in einen beliebigen anderen Schnittstellentyp, der durch diesen Werttyp implementiert wird.Boxing is the process of converting a value type to the type object or to any interface type implemented by this value type. Wenn die CLR einen Werttyp schachtelt, wird der Wert in einem System.Object geschachtelt und im verwalteten Heap gespeichert.When the CLR boxes a value type, it wraps the value inside a System.Object and stores it on the managed heap. Durch Unboxing wird der Werttyp aus dem Objekt extrahiert.Unboxing extracts the value type from the object. Boxing ist implizit, Unboxing ist explizit.Boxing is implicit; unboxing is explicit. Das Konzept von Boxing und Unboxing unterliegt der einheitlichen C#-Ansicht des Typsystems, in dem ein Wert eines beliebigen Typs als Objekt behandelt werden kann.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.

Im folgenden Beispiel wird die ganzzahlige Variable i mittels Boxing konvertiert und dem Objekt o zugewiesen.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;  

Das Objekt o kann dann mittels Unboxing zurückkonvertiert und der ganzzahligen Variablen i zugewiesen werden:The object o can then be unboxed and assigned to integer variable i:

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

Die folgenden Beispiele veranschaulichen, wie Boxing in C# verwendet wird.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

LeistungPerformance

Im Verhältnis zu einfachen Zuweisungen sind Boxing und Unboxing rechentechnisch aufwändige Prozesse.In relation to simple assignments, boxing and unboxing are computationally expensive processes. Wenn ein Werttyp mittels Boxing konvertiert wird, muss ein neues Objekt zugeordnet und erstellt werden.When a value type is boxed, a new object must be allocated and constructed. Die für Unboxing erforderliche Umwandlung ist ebenfalls, jedoch in geringerem Maße rechentechnisch aufwändig.To a lesser degree, the cast required for unboxing is also expensive computationally. Weitere Informationen finden Sie unter Leistung.For more information, see Performance.

BoxingBoxing

Boxing wird verwendet, um Werttypen im Heap der Garbage Collection zu speichern.Boxing is used to store value types in the garbage-collected heap. Beim Boxing handelt es sich um die implizite Konvertierung eines Werttyps in den Typ object oder in einen beliebigen anderen Schnittstellentyp, der durch diesen Werttyp implementiert wird.Boxing is an implicit conversion of a value type to the type object or to any interface type implemented by this value type. Beim Boxing eines Werttyps wird auf dem Heap eine Objektinstanz zugeordnet. Anschließend wird der Wert in das neue Objekt kopiert.Boxing a value type allocates an object instance on the heap and copies the value into the new object.

Beachten Sie die folgende Deklaration einer Werttypvariablen:Consider the following declaration of a value-type variable:

int i = 123;

Mit der folgenden Anweisung wird der Boxing-Vorgang implizit auf die Variable i angewendet:The following statement implicitly applies the boxing operation on the variable i:

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

Diese Anweisung bewirkt, dass der Objektverweis o auf dem Stapel erstellt wird, der auf einen Wert vom Typ int auf dem Heap verweist.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. Dieser Wert ist eine Kopie des Werttyps, der der Variablen i zugewiesen ist.This value is a copy of the value-type value assigned to the variable i. In der folgenden Abbildung ist der Unterschied zwischen den Variablen i und o dargestellt.The difference between the two variables, i and o, is illustrated in the following figure.

Grafik zu BoxingConversionBoxingConversion graphic
Boxing-KonvertierungBoxing Conversion

Es auch möglich, das Boxing wie im folgenden Beispiel explizit auszuführen. Explizites Boxing ist jedoch nie erforderlich: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

In diesem Beispiel wird die Ganzzahlvariable i mittels Boxing in das Objekt o konvertiert.This example converts an integer variable i to an object o by using boxing. Anschließend wird der in der Variablen i gespeicherte Wert von 123 in 456 geändert.Then, the value stored in the variable i is changed from 123 to 456. Das Beispiel veranschaulicht, dass der ursprüngliche Werttyp und das durch Boxing entstehende Objekt unterschiedliche Speicherorte verwenden und daher verschiedene Werte speichern können.The example shows that the original value type and the boxed object use separate memory locations, and therefore can store different values.

BeispielExample

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

Beim Unboxing handelt es sich um eine explizite Konvertierung vom object-Typ in einen Werttyp bzw. von einem Schnittstellentyp in einen Werttyp, durch den die Schnittstelle implementiert wird.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. Ein Unboxing-Vorgang umfasst folgende Schritte:An unboxing operation consists of:

  • Überprüfen der Objektinstanz, um sicherzustellen, dass es sich um einen mittels Boxing "verpackten" Wert des jeweiligen Werttyps handelt.Checking the object instance to make sure that it is a boxed value of the given value type.

  • Kopieren des Werts aus der Instanz in die Werttypvariable.Copying the value from the instance into the value-type variable.

Anhand der folgenden Anweisungen werden sowohl Boxing-Vorgänge als auch Unboxing-Vorgänge veranschaulicht:The following statements demonstrate both boxing and unboxing operations:

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

In der folgenden Abbildung ist das Ergebnis der vorherigen Anweisungen dargestellt.The following figure demonstrates the result of the previous statements.

Grafik zu UnBoxingConversionUnBoxing Conversion graphic
Unboxing-KonvertierungUnboxing Conversion

Damit das Unboxing eines Werttypen zur Laufzeit erfolgreich verläuft, muss das zu konvertierende Element ein Verweis auf ein Objekt sein, das zuvor durch Boxing einer Instanz dieses Werttyps erstellt wurde.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. Der Versuch, ein Unboxing durchzuführen, null löst ein NullReferenceException aus.Attempting to unbox null causes a NullReferenceException. Der Versuch, einen Verweis auf einen nicht kompatiblen Werttyp mittels Unboxing zu konvertieren, führt zu einer InvalidCastException.Attempting to unbox a reference to an incompatible value type causes an InvalidCastException.

BeispielExample

Im folgenden Beispiel wird ein Fall von ungültigem Unboxing und der sich daraus ergebenden InvalidCastException veranschaulicht.The following example demonstrates a case of invalid unboxing and the resulting InvalidCastException. Bei Verwendung von try und catch wird eine Fehlermeldung angezeigt, wenn der Fehler auftritt.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);
        }
    }
}

Dieses Programm gibt Folgendes aus:This program outputs:

Specified cast is not valid. Error: Incorrect unboxing.

Wenn Sie die AnweisungIf you change the statement:

int j = (short) o;  

in:to:

int j = (int) o;  

ändern, wird die Konvertierung ausgeführt und Folgendes ausgegeben.the conversion will be performed, and you will get the output:

Unboxing OK.

C#-ProgrammiersprachenspezifikationC# Language Specification

Weitere Informationen erhalten Sie unter C#-Sprachspezifikation. Die Sprachspezifikation ist die verbindliche Quelle für die Syntax und Verwendung von C#.

Weitere Informationen finden Sie unter: For more information:

C#-ProgrammiersprachenspezifikationC# Language Specification

Weitere Informationen erhalten Sie unter C#-Sprachspezifikation. Die Sprachspezifikation ist die verbindliche Quelle für die Syntax und Verwendung von C#.

Siehe auchSee Also

C#-ProgrammierhandbuchC# Programming Guide