Boxing and Unboxing (C# programozási útmutató)
A boxing az értéktípus típussá object
vagy az ilyen értéktípus által implementált felülettípussá alakításának folyamata. Amikor a közös nyelvi futtatókörnyezet (CLR) egy értéktípust ad meg, az egy System.Object példányba burkolja az értéket, és a felügyelt halomra tárolja. A kicsomagolás kinyeri az értéktípust az objektumból. A boxing implicit; a unboxing explicit. Az ökölvívás és a dobozolás fogalma annak a típusrendszernek a C# egységes nézetét használja, amelyben bármilyen típusú érték objektumként kezelhető.
Az alábbi példában az egész szám változó i
be van jelölve, és hozzá van rendelve az objektumhozo
.
int i = 123;
// The following line boxes i.
object o = i;
Az objektum o
ezután ki van jelölve, és hozzárendelhető az egész szám változóhoz i
:
o = 123;
i = (int)o; // unboxing
Az alábbi példák bemutatják, hogyan használják a boxolást a C#-ban.
// 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
Teljesítmény
Az egyszerű feladatokhoz képest a boxolás és a dobozolás számításilag költséges folyamat. Ha egy értéktípus be van jelölve, egy új objektumot kell lefoglalni és létrehozni. Kisebb mértékben a kicsomagoláshoz szükséges stáb is költséges számítással. További információ: Teljesítmény.
Boksz
A dobozolással értéktípusokat tárolhat a szemétgyűjtési halomban. A boxing egy értéktípus implicit átalakítása az értéktípus típusára object
vagy az ezzel az értéktípussal implementált felülettípusra. Az értéktípus dobozolásával lefoglal egy objektumpéldányt a halomra, és átmásolja az értéket az új objektumba.
Fontolja meg egy érték típusú változó következő deklarációját:
int i = 123;
A következő utasítás implicit módon alkalmazza a boxing műveletet a változóra i
:
// Boxing copies the value of i into object o.
object o = i;
Ennek az utasításnak az eredménye egy objektumhivatkozás o
létrehozása a veremen, amely egy, a halomra mutató típusra int
hivatkozik. Ez az érték a változóhoz i
rendelt értéktípus értékének másolata. A két változó i
o
közötti különbséget a boxing konverzió alábbi képe szemlélteti:
A boxolást explicit módon is végrehajthatja, ahogyan az alábbi példában is látható, de az explicit ökölvívás soha nem szükséges:
int i = 123;
object o = (object)i; // explicit boxing
Példa
Ez a példa egy egész szám változót i
alakít át objektummá o
a boxing használatával. Ezután a változóban i
tárolt érték a következőre 123
456
változik: . A példa azt mutatja, hogy az eredeti értéktípus és a dobozos objektum külön memóriahelyeket használ, ezért különböző értékeket tárolhat.
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
A kicsomagolás explicit átalakítás a típusról object
értéktípusra, vagy egy felülettípusról egy olyan értéktípusra, amely megvalósítja az interfészt. A kicsomagolási művelet a következőkből áll:
Ellenőrizze az objektumpéldányt, hogy az az adott értéktípus dobozos értéke-e.
Az érték másolása a példányból az érték típusú változóba.
Az alábbi utasítások a dobozolást és a dobozolást is bemutatják:
int i = 123; // a value type
object o = i; // boxing
int j = (int)o; // unboxing
Az alábbi ábra az előző állítások eredményét mutatja be:
Ahhoz, hogy az értéktípusok a futtatáskor sikeresek legyenek, a kicsomagolt elemnek olyan objektumra kell hivatkoznia, amelyet korábban az adott értéktípus egy példányának beírásával hoztak létre. Ha megkísérli feloldani a jelölőnégyzetet null
, a rendszer egy NullReferenceException. Ha egy nem kompatibilis értéktípusra mutató hivatkozást próbál meg kicsomagosítani, az egy InvalidCastException.
Példa
Az alábbi példa egy érvénytelen törlési és az eredményül InvalidCastException
kapott esetet mutatja be. A használat try
és catch
a , hibaüzenet jelenik meg a hiba bekövetkezésekor.
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);
}
}
}
Ez a program a következő kimeneteket adja ki:
Specified cast is not valid. Error: Incorrect unboxing.
Ha módosítja az utasítást:
int j = (short)o;
erre:
int j = (int)o;
a konvertálást végrehajtjuk, és a kimenet a következő lesz:
Unboxing OK.
C# nyelvspecifikáció
További információkért lásd a C# nyelvi specifikációját. A nyelvi specifikáció a C#-szintaxis és -használat végleges forrása.
Lásd még
Visszajelzés
https://aka.ms/ContentUserFeedback.
Hamarosan elérhető: 2024-ben fokozatosan kivezetjük a GitHub-problémákat a tartalom visszajelzési mechanizmusaként, és lecseréljük egy új visszajelzési rendszerre. További információ:Visszajelzés küldése és megtekintése a következőhöz: