Value Types, Reference Types and Boxing in C#

How data is stored and copied is the root of many C# interview questions. This article covers the whole family: value versus reference types, boxing, equality, the type keywords, and parameter passing.

Value types and reference types

Point p1 = new() { X = 1 };
Point p2 = p1;                    // copies the data
p2.X = 99;
Console.WriteLine(p1.X);          // 1

Box b1 = new() { X = 1 };
Box b2 = b1;                      // copies the reference
b2.X = 99;
Console.WriteLine(b1.X);          // 99

public struct Point { public int X; }   // value type
public class Box { public int X; }      // reference type

"Value types live on the stack": the accurate version

That answer is common but incomplete. A value-type variable stores its data where the variable lives:

• a local int lives on the stack (or in a CPU register),
• an int field of a class lives inside that object, on the heap,
• the elements of an int[] live inside the array object, on the heap.

Objects of reference types always live on the heap. The reference itself is just a value, and it lives wherever the variable lives. Saying this precisely is a reliable way to stand out.

Boxing and unboxing

Boxing converts a value type to object (or to an interface it implements). The runtime allocates an object on the heap and copies the value into it. Unboxing casts it back, and it must name the exact original type.

int number = 42;
object boxed = number;            // boxing: allocates a heap object
int copy = (int)boxed;            // unboxing: copies the value back
boxed = 100;                      // changes only the boxed object
Console.WriteLine(number);        // 42
Console.WriteLine((int)boxed);    // 100

try
{
    long wrong = (long)boxed;     // the box holds an int, not a long
}
catch (InvalidCastException)
{
    Console.WriteLine("cannot unbox an int as a long");
}

Boxing costs an allocation, and allocations create work for the garbage collector. It happens quietly when you put value types in non-generic collections such as ArrayList, pass them as object, or call interface methods on a struct. Generic collections like List<int> avoid it.

== versus Equals()

• == is an operator. For value types it compares values. For reference types it compares references unless the type overloads it (string does, so == compares text).
• Equals() is a virtual method. The default compares references for classes and fields for structs. Types such as string and record override it to compare content.

string a = "hello";
string b = new string("hello".ToCharArray());   // a different object with the same text
object oa = a;
object ob = b;

Console.WriteLine(a == b);                      // True   (string overloads ==)
Console.WriteLine(ReferenceEquals(a, b));       // False  (two different objects)
Console.WriteLine(oa == ob);                    // False  (static type object: reference comparison)
Console.WriteLine(oa.Equals(ob));               // True   (the virtual Equals is string's)

The third line is the one that catches people: the operator is chosen by the compile-time type, while is chosen by the run-time type.

var, object and dynamic

const versus readonly

Use for true constants like , and for values computed at start-up.

ref, out and in

All three pass an argument by reference instead of copying it.

Nullable types

A value type cannot be . is shorthand for , a struct with a flag and a :

Reading while is false throws , so use or . Nullable reference types () are a different feature: annotations that make the compiler warn about possible dereferences. Treat those warnings as bugs.

Practise

1. Predict, then run, the and example. Change to and run it again.
2. Write a loop that appends values to an , then rewrite it with . Where does the boxing disappear?
3. Take the Types, Strings and OOP quiz.