Boxing is the process of converting a value type to the type object or to any interface type implemented by this value type. When the CLR boxes a value type, it wraps the value inside a System.Object and stores it on the managed heap. Unboxing extracts the value type from the object. Boxing is implicit; unboxing is explicit. The concept of boxing and unboxing underlies the C# unified view of the type system in which a value of any type can be treated as an object.

See the code below with several boxing and unboxing examples

 using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

 namespace BoxingUnboxing
{
    class Program
    {
        static void Main(string[] args)
        {
            // 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));
            // burada 42 ve true string seklinde box laniyor
            // 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);
                Console.Write(item); Console.Write(" "); Console.WriteLine(item.GetType());
            }

             // 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];
                // burada da unboxing ornegi var
                // mixedList denen icinde boxed variable lerin oldugu liste burada her biri unbox ediliyor 
                // yeniden gosteriliyor
            }

             Console.ReadKey();
        }
    }

}