Poznámka
Přístup k této stránce vyžaduje autorizaci. Můžete se zkusit přihlásit nebo změnit adresáře.
Přístup k této stránce vyžaduje autorizaci. Můžete zkusit změnit adresáře.
Zabalení je proces převodu typu hodnoty na typ object nebo na libovolný typ rozhraní implementovaný tímto typem hodnoty.Když pole CLR umístí typ hodnoty do pole, obtéká hodnotu uvnitř System.Object a uloží ji na spravované haldě.Rozbalení extrahuje typ hodnoty z objektu.Zabalení je implicitní; rozbalení je explicitní.Pojem zabalení a rozbalení se vztahuje na sjednocené zobrazení C# systému typů, ve kterém lze považovat hodnotu libovolného typu za objekt.
V následujícím příkladu proměnná integer i je zabalena a přiřazena k objektu o.
int i = 123;
// The following line boxes i.
object o = i;
Objekt o lze potom rozbalit a přiřadit k proměnné celého čísla i:
o = 123;
i = (int)o; // unboxing
Následující příklady ilustrují použití zabalení v jazyce 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
Výkon
Vzhledem k jednoduchým přiřazením jsou zabalení a rozbalení výpočetně náročné procesy.Když je hodnotový typ v poli, je nutné přidělit a vytvořit nový objekt.V menší míře je přetypování potřebné pro rozbalení také nákladné výpočetně.Další informace viz Výkon.
Zabalení
Zabalení slouží k uložení typů hodnot haldy uvolňování paměti.Zabalení je implicitní převod typ hodnotu na typ object nebo na libovolný typ rozhraní implementovaný tímto typem hodnoty.Zabalení typu hodnoty přiděluje instance objektu na haldě a kopíruje hodnotu do nového objektu.
Zvažte například následující typ deklarace proměnné hodnotového typu:
int i = 123;
Následující příkaz se implicitně týká operace zabalení pro proměnnou i:
// Boxing copies the value of i into object o.
object o = i;
Výsledkem tohoto příkazu je vytvoření odkazu na objekt o v zásobníku, který odkazuje na hodnotu typu int v haldě.Tato hodnota je kopií hodnoty hodnotového typu přiřazené k proměnné i.Rozdíl mezi dvěma proměnnými, i a o, je znázorněn na následujícím obrázku.
Převod zabalením
Je také možné provést zabalení explicitně jako v následujícím příkladu, ale nikdy není vyžadováno explicitní zabalení:
int i = 123;
object o = (object)i; // explicit boxing
Description
V tomto příkladu se převede celočíselná proměnná i na objekt o pomocí uzavřeného určení.Následně je hodnota uložená v proměnné i změněna z 123 na 456.Příklad ukazuje, že typ původní hodnoty a zabalený objekt používají samostatná paměťová místa a proto mohou uchovávat různé hodnoty.
Příklad
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
*/
Následující příklad ukazuje případ neplatného rozbalení a výsledné InvalidCastException.Použitím try a catch se zobrazí chybová zpráva, když dojde k chybě.
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);
}
}
}
Výstup tohoto programu:
Specified cast is not valid. Error: Incorrect unboxing.
Pokud změníte příkaz:
int j = (short) o;
až:
int j = (int) o;
převod bude proveden a zobrazí se výstup:
Unboxing OK.
Rozbalení
Rozbalení je explicitní převod z typu object na typ hodnoty, nebo z typu rozhraní na typ hodnoty, který implementuje rozhraní.Operace rozbalení se skládá ze:
Kontrola instance objektu pro ověření, že se jedná o zabalenou hodnotu daného typu hodnoty.
Kopírování hodnoty z instance do proměnné typu hodnoty.
Následující příkazy ukazují operace zabalení a rozbalení:
int i = 123; // a value type
object o = i; // boxing
int j = (int)o; // unboxing
Následující obrázek ukazuje výsledek předchozích příkazů.
Převod rozbalením
Pro rozbalení typů hodnot v době spuštění úspěšné, musí být rozbalená položka odkazem na objekt, který byl dříve vytvořen zabalením instance tohoto typu hodnoty.Při pokusu o rozbalení null způsobí NullReferenceException.Při pokusu o vybalení odkazu na nekompatibilní hodnotu způsobí typ InvalidCastException.
Specifikace jazyka C#
Další informace najdete v tématu Specifikace jazyka C#. Specifikace jazyka je úplným a rozhodujícím zdrojem pro syntaxi a použití jazyka C#.
Související oddíly
Další informace:
Specifikace jazyka C#
Další informace najdete v tématu Specifikace jazyka C#. Specifikace jazyka je úplným a rozhodujícím zdrojem pro syntaxi a použití jazyka C#.