Aracılığıyla paylaş

Kutulama ve Kutudan çıkarma (C# Programlama Kılavuzu)

Kutulama, bir değer türünü türe object veya bu değer türü tarafından uygulanan herhangi bir arabirim türüne dönüştürme işlemidir. Ortak dil çalışma zamanı (CLR) bir değer türünü kutuladığında, değeri bir System.Object örneğin içine sarmalar ve yönetilen yığında depolar. Kutulama, nesneden değer türünü ayıklar. Paketleme örtülüdür; kutudan çıkarma açıktır. C# birlik tür sistemi görünümünün temelini oluşturan kutulama ve kutudan çıkarma kavramı, herhangi bir türdeki bir değerin nesne olarak ele alınabilmesini sağlar.

Aşağıdaki örnekte, tamsayı değişkeni ikutulanır ve nesnesine oatanır.

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

o Nesne daha sonra kutusu kaldırılabilir ve tamsayı değişkenine iatanabilir:

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

Aşağıdaki örneklerde, C# dilinde kutulamanın nasıl kullanıldığı gösterilmektedir.

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

Gösteri

Basit atamalarla ilgili olarak, kutulama ve kutudan çıkarma hesaplama açısından maliyetli işlemlerdir. Bir değer türü kutulandığında, yeni bir nesne ayrılıp oluşturulmalıdır. Daha az ölçüde, kutulama işlemi için gerekli olan tür dönüştürme işlem açısından da pahalıdır. Daha fazla bilgi için performansbakınız.

Boks

Boks, çöp toplanan yığında değer türlerini depolamak için kullanılır. Boxing, bir değer türünüobject türüne veya bu değer türü tarafından uygulanan herhangi bir arabirim türüne örtük olarak dönüştürme işlemidir. Bir değer türünü kutulamak, yığında ayrı olarak bir nesne örneği ayırır ve değeri yeni nesneye kopyalar.

Bir değer türü değişkeninin aşağıdaki bildirimini göz önünde bulundurun:

int i = 123;

Aşağıdaki deyim, değişken i üzerinde kutulama işlemini örtük olarak uygular:

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

Bu deyimin sonucu, yığında bir nesne referansı o oluşturarak heap'te türünde int bir değere referans vermektir. Bu değer, değişkenine iatanan değer türü değerinin bir kopyasıdır. İki değişken, i ve o, arasındaki fark aşağıdaki "boxing conversion" görüntüsünde gösterilmiştir.

i ve o değişkenleri arasındaki farkı gösteren grafik.

Aşağıdaki örnekte olduğu gibi kutulama açıkça gerçekleştirilmesi de mümkündür, ancak açık kutulama hiçbir zaman gerekli değildir:

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

Örnek

Bu örnek, kutulama kullanarak bir tamsayı değişkenlerini i nesneye o dönüştürür. Ardından, değişkende i depolanan değer 123'den 456'ye değiştirilir. Örnekte özgün değer türü ve kutulanmış nesnenin ayrı bellek konumları kullandığı ve bu nedenle farklı değerleri depolayabildiği gösterilmektedir.

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

Kutudan çıkarma

Kutudan Çıkarma, tür object'den bir değer türüne veya bir arabirim türünden arabirimi uygulayan bir değer türüne açık bir dönüştürmedir. Kutulama kaldırma işlemi şunlardan oluşur:

  • Verilen değer türünün kutulanmış değeri olduğundan emin olmak için nesne örneğini denetleme.

  • Örnekteki değeri değer türü değişkenine kopyalama.

Aşağıdaki deyimler hem kutulama hem de kutu açma işlemlerini gösterir:

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

Aşağıdaki şekilde, önceki deyimlerin sonucu gösterilmektedir:

Kutudan çıkarma dönüşümünü gösteren grafik.

Çalışma zamanında değer türlerinin kutudan çıkarma işleminin başarılı olması için ayıklanmakta olan öğenin daha önce bu değer türünün bir örneğini kutulayarak oluşturulmuş bir nesneye başvuru olması gerekir. Kutusunun null kaldırılmaya çalışılması bir NullReferenceExceptionneden olur. Uyumsuz bir değer türüne yönelik bir başvuruyu çözmeye çalışmak, InvalidCastException hatasına neden olur.

Örnek

Aşağıdaki örnek, geçersiz bir kutusundan çıkarma işlemi ve bunun sonucunda ortaya çıkan durumu göstermektedir InvalidCastException. ve trycatchkullanıldığında, hata oluştuğunda bir hata iletisi görüntülenir.

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

Bu program şunları çıkış olarak oluşturur:

Specified cast is not valid. Error: Incorrect unboxing.

İfadeyi değiştirirseniz:

int j = (short)o;

yerine şunu yazın:

int j = (int)o;

dönüştürme gerçekleştirilir ve çıkışı alırsınız:

Unboxing OK.

C# dil belirtimi

Daha fazla bilgi edinmek için, bkz. C# Dil Belirtimi. Dil belirtimi, C# söz dizimi ve kullanımı için kesin kaynaktır.

Ayrıca bakınız