Bagikan melalui

Boxing dan Unboxing (Panduan Pemrograman C#)

Tinju adalah proses mengonversi jenis nilai ke jenis object atau ke jenis antarmuka apa pun yang diimplementasikan oleh jenis nilai ini. Ketika runtime bahasa umum (CLR) mengonversi tipe nilai, nilai tersebut dibungkus di dalam instance System.Object dan disimpan di tumpukan yang terkelola. Pembukaan kotak mengekstrak jenis nilai dari objek. Tinju bersifat implisit; membongkar bersifat eksplisit. Konsep pembungkusan dan pembongkaran mendasari pandangan terpadu C# dari sistem tipe di mana nilai dari tipe apa pun dapat diperlakukan sebagai objek.

Dalam contoh berikut, variabel bilangan bulat idikotak dan ditetapkan ke objek o.

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

Objek o kemudian dapat dikotak dan ditetapkan ke variabel bilangan bulat i:

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

Contoh berikut mengilustrasikan bagaimana tinju digunakan dalam 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

Penampilan

Sehubungan dengan tugas sederhana, pengotakan dan unboxing adalah proses yang memerlukan banyak sumber daya komputasi. Saat jenis nilai dikotak, objek baru harus dialokasikan dan dibangun. Untuk tingkat yang lebih rendah, cast yang diperlukan untuk unboxing juga mahal secara komputasi. Untuk informasi selengkapnya, lihat Performa.

Tinju

Boxing digunakan untuk menyimpan tipe nilai dalam heap yang dikelola oleh pengumpul sampah. Boxing adalah konversi implisit dari tipe nilai ke tipe object atau ke tipe antarmuka apa pun yang diterapkan oleh tipe nilai ini. Pengepakan tipe nilai mengalokasikan instans objek pada tumpukan memori dan menyalin nilai ke dalam objek baru.

Pertimbangkan deklarasi variabel jenis nilai berikut:

int i = 123;

Pernyataan berikut secara implisit menerapkan operasi pembungkusan pada variabel i:

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

Hasil dari pernyataan ini adalah membuat referensi objek o, pada tumpukan, yang mereferensikan nilai jenis int, pada tumpukan. Nilai ini adalah salinan nilai jenis nilai yang ditetapkan ke variabel i. Perbedaan antara dua variabel, i dan o, diilustrasikan dalam gambar konversi tinju berikut:

Grafik memperlihatkan perbedaan antara variabel i dan o.

Dimungkinkan juga untuk melakukan tinju secara eksplisit seperti dalam contoh berikut, tetapi tinju eksplisit tidak pernah diperlukan:

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

Contoh

Contoh ini mengonversi variabel bilangan bulat i ke objek o dengan menggunakan tinju. Kemudian, nilai yang disimpan dalam variabel i diubah dari 123 menjadi 456. Contoh menunjukkan bahwa jenis nilai asli dan objek berkotak menggunakan lokasi memori terpisah, dan karenanya dapat menyimpan nilai yang berbeda.

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

Pembukaan Kotak

Unboxing adalah konversi eksplisit dari jenis object ke jenis nilai atau, atau dari jenis antarmuka ke jenis nilai yang mengimplementasikan antarmuka. Operasi pembukaan kotak terdiri dari:

  • Mencentang instans objek untuk memastikan bahwa instans tersebut adalah nilai kotak dari jenis nilai yang diberikan.

  • Menyalin nilai dari instans ke dalam variabel jenis nilai.

Pernyataan berikut menunjukkan operasi tinju dan membuka kotak:

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

Gambar berikut menunjukkan hasil pernyataan sebelumnya:

Grafik menunjukkan proses unboxing.

Agar unboxing tipe nilai berhasil pada waktu proses, item yang di-unbox harus menjadi referensi ke objek yang sebelumnya dibuat dengan mengkotakkan instans dari tipe nilai tersebut. Mencoba membuka kotak null menyebabkan NullReferenceException. Mencoba membuka kotak referensi ke jenis nilai yang tidak kompatibel menyebabkan InvalidCastException.

Contoh

Contoh berikut menunjukkan kasus unboxing yang tidak valid dan InvalidCastExceptionyang dihasilkan. Menggunakan try dan catch, pesan kesalahan ditampilkan saat kesalahan terjadi.

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.");
        }
    }
}

Output program ini:

Specified cast is not valid. Error: Incorrect unboxing.

Jika Anda mengubah pernyataan:

int j = (short)o;

untuk:

int j = (int)o;

konversi akan dilakukan, dan Anda akan mendapatkan output:

Unboxing OK.

Spesifikasi bahasa C#

Untuk informasi selengkapnya, lihat Spesifikasi Bahasa C#. Spesifikasi bahasa adalah sumber definitif untuk sintaks dan penggunaan C#.

Lihat juga