Boxing a Unboxing (C# programování Guide)

Boxerská je proces převodu Typ hodnoty typu object nebo na libovolný typ rozhraní implementované tento typ hodnoty.Když CLR pole Typ hodnoty, obtéká hodnotu uvnitř System.Object a ukládá ve spravovaných haldách.Typ hodnoty unboxing extrahuje z objektu.Boxerská je implicitní; unboxing je explicitní.Pojem boxerská a unboxing podkladové zobrazení unified C#, typ systému, ve kterém můžete považovány hodnota libovolný typ objektu.

V následujícím příkladu celočíselná proměnná i je boxed a přiřazené k objektu o.

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

Objekt o lze potom unboxed a přiřazen proměnné integer i:

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

Následující příklady ilustrují použití boxerská 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

Ve vztahu k jednoduché přiřazení boxerská a unboxing jsou výpočetně náročné procesy.Pokud je typ hodnoty v rámečku, musí být nový objekt přidělena a vyrobeno.V menší míře osazení pro unboxing je také nákladné výpočetně.Další informace naleznete v tématu výkon.

Boxerská

Boxerská slouží k uložení hodnoty typů haldy pro něho uvolněna.Boxerská je implicitní převod Typ hodnoty typu object nebo na libovolný typ rozhraní implementované tento typ hodnoty.Boxing typ hodnoty přiděluje instanci objektu na haldy a hodnota zkopírována do nového objektu.

Zvažte následující deklaraci proměnné typ hodnoty:

int i = 123;

Implicitně platí následující prohlášení boxerská operace na proměnné i:

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

V důsledku tohoto příkazu je vytváření odkaz na objekt o, v zásobníku, který odkazuje na hodnotu typu int, na haldy.Tato hodnota je kopie typ hodnoty hodnotu přiřazenou k proměnné i.Rozdíl mezi dvě proměnné i a o, je znázorněn na následujícím obrázku.

Převod boxerská

Je také možné provést boxerská explicitně v následujícím příkladu, ale explicitní boxerská se nikdy vyžaduje:

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

Description

V tomto příkladu převede proměnná typu integer i objektu o pomocí boxerská.Potom hodnotu uloženou v proměnné i je změněn z 123 na 456.Příklad ukazuje, že původní hodnota typu krabici objektu použít samostatné paměťových míst a proto můžete uchovat 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ý unboxing a výsledný InvalidCastException.Pomocí try a catch, dojde k chybě, zobrazí se chybová zpráva.

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ýstupem tohoto programu:

Specified cast is not valid. Error: Incorrect unboxing.

Pokud změníte prohlášení:

int j = (short) o;

do:

int j = (int) o;

Převod bude proveden a zobrazí výstup:

Unboxing OK.

Na volné určení.

Unboxing je explicitní převod z typu object se Typ hodnoty nebo z typu rozhraní na hodnotu typu, která implementuje rozhraní.Na volné určení operace se skládá ze:

• Kontrola zda je krabici hodnotu dané hodnoty typu instance objektu.

• Kopírování hodnoty z instance do proměnné typu hodnoty.

Následující příkazy prokázat boxing i na volné určení operace:

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

Následující obrázek znázorňuje výsledek předchozího prohlášení.

Převod na volné určení.

Položky jsou unboxed unboxing typy hodnot úspěšný při běhu musí být odkaz na objekt, který byl dříve vytvořen boxing instance typu hodnoty.Při pokusu o unbox null způsobí, že NullReferenceException.Došlo k pokusu o odkaz na nekompatibilní hodnotu unbox zadejte příčin InvalidCastException.

Specifikace jazyka C#

Další informace naleznete 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:

• Odkazové typy

• Typy hodnot

Specifikace jazyka C#

Další informace naleznete v tématu Specifikace jazyka C#. Specifikace jazyka je úplným a rozhodujícím zdrojem pro syntaxi a použití jazyka C#.

Viz také

Koncepty

Příručka programování C#