Learn C# boxing and unboxing easily

First of all, let’s take a look at what is boxing and unboxing?
Simple:
Packing is the value type conversion to reference type;
The box removal is the reference type to the value type.
Value types include primitive types (Sbyte, Byte, Short, Ushort, Int, Uint, Long, Ulong, Char, Float, Double, Bool, Decimal), enumeration (enum), and structure (struct).
Reference types include classes, arrays, interfaces, delegates, strings, etc.

Boxing: Implicit conversion from a value type to a reference type or to any interface type implemented by this value type
For example: int temp = 3;
System.Object obj = temp;
Among them, temp is a value type and is allocated on the stack; when allocating the reference type obj, we need to allocate an obj object in the heap and then assign the temp value to it. Such a series of processes is to install box process.

Unboxing: Explicit conversion from reference type to arbitrary value type. Unlike boxing, unboxing displays transformations.
For example: int temp = 3;
System.Object obj = temp;
int i = (int) obj;
During the unboxing process, first determine that the object obj is a value type. box value and then assign the value to the value type.
Implicit conversion will always succeed and no exception will be thrown:
　(1), from derived class to base class;
　(2), from derived interface to base interface;
　( 3), from class to interface (the class implements the interface);
(4), from Null to any class;
Explicit reference conversion, the following may throw an exception, and the conversion may not be successful:
(1), from base class to derived class;
　 (2), from interface to interface (base interface to derived interface or the two interfaces have no relationship);
　 (3), from interface to class (the class implements The interface or the class is not closed);
　(4), from class to interface (the class does not implement the interface and the class is not closed);

The above briefly introduces the disassembly The definition of boxing and boxing, let's discuss how to use boxing and unboxing and heap and stack
The value type allocates memory on the stack, and the declaration itself is an initialization process, which does not require garbage Recycling will automatically release memory as long as it exceeds the defined scope, and reference types are allocated in the heap. Like Java, memory is allocated in the heap, and its managed heap performs garbage collection. Boxing/unboxing occurs when two data types are converted.
Compare the advantages and disadvantages of boxing and unboxing
Although boxing and unboxing satisfy the conversion between two types. However, it is not difficult to see from the boxing process that a new object must be added to the heap each time it is boxed. If the size is particularly large, it will definitely greatly affect the efficiency of the program. Things always have two sides, every sword has two sides, things become simpler and performance is reduced. Therefore, in applications, we should try to avoid boxing operations.
Understanding the operations of boxing and unboxing, we can clearly understand that boxing operations will cause data to be copied on the heap and stack, and frequent boxing operations will cause performance losses. In comparison, the performance loss caused by the unboxing process is relatively small.
Detailed steps for packing and unboxing

1. Detailed steps for packing (box):

(1) Allocate a memory space on the heap, the size of which is equal to the size of the value type object that needs to be boxed plus the members owned by both reference type objects: the type object pointer and the synchronized block reference.
 (2) Copy the value type object on the stack to the newly allocated object on the heap.
(3) Return a reference to the new object on the heap and store it in the boxed value type object on the stack.
       This step does not require programmers to write it themselves. Wherever boxing occurs, the compiler will automatically add IL code to perform the above functions.
The so-called unboxing is the concept corresponding to boxing, but the process of unboxing and packing are not the other way around:
2. Detailed steps of unboxing (unbox.any)
If you are waiting The unboxed object is null and a NullReferenceException is thrown.
If the reference points to a boxed object that is not the expected object, an InvalidCastException is thrown.
 (1) Obtain the address of each field in the boxed object. This process is "unboxing"
It should be noted that generally unboxing will be accompanied by a copy of the object, but the copy operation is no longer unboxing category.

The following are two small examples to realize what boxing and unboxing are and how to avoid consuming memory due to frequent boxing
(1), boxing:

using System;
   public class Test
   {
         public static void Main(String[] args)
        {
            int i = 10;
            //将值类型的i装箱
            //需要注意的是:这里的装箱采用的是值的拷贝
            object obj = i;
            //检验是否装箱成功了
            if(obj is int)
            {
               Console.WriteLine("数据已经装箱!");
            }
            //我们在这里更改i的值
            i = 33;
            Console.WriteLine("int i现在的值是:{0}",i);
           Console.WriteLine("int i装箱的值是:{0}",obj);
       }
    }

(2) Unboxing:

int i = 10;
    object obj = i;
    int j = (int)obj;
   （3）、避免频繁的装箱：
    int i = 10;
    int j = 20;
    int s = 30;
    Console.WriteLine("i的值为{0}，j的值为{1}，s的值为{2}", i.ToString(), j.ToString(), s.ToString());

The above is an introduction to the packing and unboxing of C#, the idea is very clear , the content involved is very comprehensive, including the advantages and disadvantages of packing and unboxing, the steps of packing and unboxing, etc., which is very suitable for beginners to learn.

For more articles related to easily learning C# boxing and unboxing, please pay attention to the PHP Chinese website!