Boxing und Unboxing (C#-Programmierhandbuch)

Boxing ist der Prozess der Konvertierung eines Werttyps in den Typ object oder in einen beliebigen Schnittstellentyp, der von diesem Werttyp implementiert wird. Wenn die Common Language Runtime (CLR) für einen Werttyp das Boxing durchführt, wird der Wert mit einer System.Object-Instanz umschlossen und im verwalteten Heap gespeichert. Beim Entpacken wird der Werttyp aus dem Objekt extrahiert. Boxing ist implizit, Unboxing ist explizit. Das Konzept des Boxens und Entpackens unterliegt der einheitlichen Ansicht des C#-Typsystems, bei dem ein Wert eines beliebigen Typs als Objekt behandelt werden kann.

Im folgenden Beispiel wird die ganzzahlige Variable i mittels Boxing konvertiert und dem Objekt o zugewiesen.

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

Das Objekt o kann dann unboxiert und ganzzahliger Variable izugewiesen werden:

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

Die folgenden Beispiele veranschaulichen, wie Boxing in C# verwendet wird.

// 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

Leistung

Im Verhältnis zu einfachen Zuweisungen sind Boxing und Unboxing rechentechnisch aufwändige Prozesse. Wenn ein Werttyp mittels Boxing konvertiert wird, muss ein neues Objekt zugeordnet und erstellt werden. Die für Unboxing erforderliche Umwandlung ist ebenfalls, jedoch in geringerem Maße rechentechnisch aufwändig. Weitere Informationen finden Sie unter Performance.

Boxen

Boxing wird verwendet, um Werttypen im Heap der Garbage Collection zu speichern. Boxing ist eine implizite Konvertierung eines Werttyps in den Typ object oder in einen beliebigen Schnittstellentyp, der von diesem Werttyp implementiert wird. Das Boxen eines Werttyps bewirkt, dass eine Objektinstanz auf dem Heap angelegt wird und der Wert in das neue Objekt kopiert wird.

Betrachten Sie die folgende Deklaration einer Werttypvariable:

int i = 123;

Mit der folgenden Anweisung wird der Boxing-Vorgang implizit auf die Variable i angewendet:

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

Das Ergebnis dieser Anweisung ist die Erstellung eines Objektverweises o auf dem Stapel, der auf einen Wert des Typs int auf dem Heap verweist. Dieser Wert ist eine Kopie des Werttypwerts, der der Variablen izugewiesen ist. In der folgenden Abbildung der Boxing-Konversation ist der Unterschied zwischen den Variablen i und o dargestellt.

Es ist auch möglich, das Boxen explizit auszuführen, wie im folgenden Beispiel, aber explizites Boxen ist nie erforderlich:

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

Beispiel

In diesem Beispiel wird eine ganzzahlige Variable i mithilfe von Boxing in ein Objekt o konvertiert. Anschließend wird der in der Variablen i gespeicherte Wert von 123 zu 456" geändert. Das Beispiel zeigt, dass der ursprüngliche Werttyp und das boxierte Objekt separate Speicherspeicherorte verwenden und daher unterschiedliche Werte speichern können.

        // Create an int variable
        int i = 123;
        
        // Box the value type into an object reference
        object o = i;  // boxing
        
        // Display the initial values
        Console.WriteLine($"Value of i: {i}");
        Console.WriteLine($"Value of boxed object o: {o}");
        
        // Modify the original value type
        i = 456;
        
        // Display the values after modification
        Console.WriteLine("\nAfter changing i to 456:");
        Console.WriteLine($"Value of i: {i}");
        Console.WriteLine($"Value of boxed object o: {o}");
        
        // Output:
        // Value of i: 123
        // Value of boxed object o: 123

        // After changing i to 456:
        // Value of i: 456
        // Value of boxed object o: 123

Auspacken

Unboxing ist eine explizite Konvertierung vom Typ object in einen Werttyp oder von einem Schnittstellentyp zu einem Werttyp, der die Schnittstelle implementiert. Ein Unboxing-Vorgang besteht aus:

• Überprüfen der Objektinstanz, um sicherzustellen, dass es sich um einen Boxwert des angegebenen Werttyps handelt.

• Kopieren des Werts aus der Instanz in die Werttypvariable.

Anhand der folgenden Anweisungen werden sowohl Boxing-Vorgänge als auch Unboxing-Vorgänge veranschaulicht:

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

Die folgende Abbildung zeigt das Ergebnis der vorherigen Anweisungen:

Damit das Entpacken von Werttypen zur Laufzeit erfolgreich ausgeführt werden kann, muss das Element, das entpackt wird, ein Verweis auf ein Objekt sein, das zuvor durch das Boxen einer Instanz dieses Werttyps erstellt wurde. Der Versuch, ein Unboxing durchzuführen, null löst ein NullReferenceException aus. Der Versuch, einen Verweis auf einen inkompatiblen Werttyp zu entpacken, führt zu einem InvalidCastException.

Beispiel

Im folgenden Beispiel wird ein Fall von ungültigem Unboxing und der sich daraus ergebenden InvalidCastException veranschaulicht. Beim Auftreten des Fehlers wird mithilfe von try und catch eine Fehlermeldung angezeigt.

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($"{e.Message} Error: Incorrect unboxing.");
        }
    }
}

Dieses Programm gibt Folgendes aus:

Specified cast is not valid. Error: Incorrect unboxing.

Wenn Sie die Anweisung

int j = (short)o;

in:

int j = (int)o;

die Konvertierung erfolgt, und Sie erhalten die Ausgabe:

Unboxing OK.

C#-Sprachspezifikation

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

Siehe auch

• Referenztypen
• Werttypen