Boxing und Unboxing (C#-Programmierhandbuch)
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. 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. Durch Unboxing wird der Werttyp aus dem Objekt extrahiert. Boxing ist implizit, Unboxing ist explizit. 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.
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 mittels Unboxing zurückkonvertiert und der ganzzahligen Variablen i zugewiesen 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 Leistung.
Boxing
Boxing wird verwendet, um Werttypen im Heap der Garbage Collection zu speichern. 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. Beim Boxing eines Werttyps wird auf dem Heap eine Objektinstanz zugeordnet. Anschließend wird der Wert in das neue Objekt kopiert.
Beachten Sie die folgende Deklaration einer Werttypvariablen:
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;
Diese Anweisung bewirkt, dass der Objektverweis o auf dem Stapel erstellt wird, der auf einen Wert vom Typ int auf dem Heap verweist. Dieser Wert ist eine Kopie des Werttyps, der der Variablen i zugewiesen ist. In der folgenden Abbildung der Boxing-Konversation ist der Unterschied zwischen den Variablen i und o dargestellt.
Es auch möglich, das Boxing wie im folgenden Beispiel explizit auszuführen. Explizites Boxing ist jedoch nie erforderlich:
int i = 123;
object o = (object)i; // explicit boxing
Beispiel
In diesem Beispiel wird die Ganzzahlvariable i mittels Boxing in das Objekt o konvertiert. Anschließend wird der in der Variablen i gespeicherte Wert von 123 in 456 geändert. Das Beispiel veranschaulicht, dass der ursprüngliche Werttyp und das durch Boxing entstehende Objekt unterschiedliche Speicherorte verwenden und daher verschiedene Werte speichern können.
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
*/
Unboxing
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. Ein Unboxing-Vorgang umfasst folgende Schritte:
Überprüfen der Objektinstanz, um sicherzustellen, dass es sich um einen mittels Boxing "verpackten" Wert des jeweiligen 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
In der folgenden Abbildung ist das Ergebnis der vorherigen Anweisungen dargestellt:
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. Der Versuch, ein Unboxing durchzuführen, null löst ein NullReferenceException aus. Der Versuch, einen Verweis auf einen nicht kompatiblen Werttyp mittels Unboxing zu konvertieren, führt zu einer InvalidCastException.
Beispiel
Im folgenden Beispiel wird ein Fall von ungültigem Unboxing und der sich daraus ergebenden InvalidCastException veranschaulicht. Bei Verwendung von try und catch wird eine Fehlermeldung angezeigt, wenn der Fehler auftritt.
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:
Specified cast is not valid. Error: Incorrect unboxing.
Wenn Sie die Anweisung
int j = (short)o;
in:
int j = (int)o;
ändern, wird die Konvertierung ausgeführt und Folgendes ausgegeben.
Unboxing OK.
C#-Sprachspezifikation
Weitere Informationen erhalten Sie unter C#-Sprachspezifikation. Die Sprachspezifikation ist die verbindliche Quelle für die Syntax und Verwendung von C#.
