C# tutorials > Core C# Fundamentals > Basics and Syntax > What are value types and reference types?

What are value types and reference types?

Understanding the difference between value types and reference types is crucial for efficient memory management and predictable behavior in C#. Value types store their data directly within their memory allocation, while reference types store a pointer (a memory address) to the location where the data is stored. This distinction impacts how data is copied, compared, and modified in your programs.

Core Difference: Storage

The fundamental difference lies in how data is stored in memory. Value types directly hold their data, meaning when you copy a value type, you create a new independent copy of the data. Reference types, however, hold a *reference* (a pointer) to the data's location in memory. Copying a reference type copies the reference, not the data itself, meaning both references point to the same underlying data.

Value Types

Value types include:
  • `int`, `float`, `double`, `bool`, `char`, `decimal`
  • `struct`
  • `enum`
When `y` is assigned the value of `x`, a new memory location is allocated for `y`, and the value of `x` is copied into it. Therefore, modifying `y` has no effect on `x`.

csharp
int x = 10;
int y = x; // y gets a copy of x's value (10)
y = 20; // Changing y does not affect x
Console.WriteLine($"x: {x}, y: {y}"); // Output: x: 10, y: 20

Reference Types

Reference types include:
  • `class`
  • `string`
  • `interface`
  • `delegate`
  • `array`
In this example, `obj2` is assigned the *reference* of `obj1`. Both variables now point to the same object in memory. Modifying `obj2`'s `Value` property directly modifies the object that both `obj1` and `obj2` are referencing.

csharp
class MyClass
{
    public int Value { get; set; }
}

MyClass obj1 = new MyClass { Value = 10 };
MyClass obj2 = obj1; // obj2 now references the same object as obj1
obj2.Value = 20; // Changing obj2 also changes obj1
Console.WriteLine($"obj1.Value: {obj1.Value}, obj2.Value: {obj2.Value}"); // Output: obj1.Value: 20, obj2.Value: 20

Concepts Behind the Snippet (Garbage Collection)

Reference types are managed by the garbage collector (GC). When an object is no longer referenced by any variable, the GC eventually reclaims the memory that object occupied. Value types, especially local variables within methods, are often allocated on the stack and automatically deallocated when the method completes.

Real-Life Use Case: Modifying Shared Data

In a shopping cart scenario, multiple parts of an application might need to access and modify the same cart data. Using a reference type (`ShoppingCart` class) allows different parts of the code to share and update the same cart instance. The crucial thing to avoid is directly returning the internal list, in order to prevent unexpected modifications of the state by external classes. Instead a new list is returned.

csharp
using System.Collections.Generic;

public class ShoppingCart
{
    private List<string> items = new List<string>();

    public void AddItem(string item)
    {
        items.Add(item);
    }

    public List<string> GetItems()
    {
        //Return a new list instead of the internal one to avoid modifications
        return new List<string>(items); 
    }

    public override string ToString()
    {
        return string.Join(", ", items);
    }
}

public class Example
{
    public static void Main(string[] args)
    {
        ShoppingCart cart1 = new ShoppingCart();
        cart1.AddItem("Laptop");
        cart1.AddItem("Mouse");

        ShoppingCart cart2 = cart1; // Both point to the same cart

        cart2.AddItem("Keyboard");

        Console.WriteLine("Cart 1: " + cart1);
        Console.WriteLine("Cart 2: " + cart2);
        // Output: Cart 1: Laptop, Mouse, Keyboard
        // Output: Cart 2: Laptop, Mouse, Keyboard
    }
}

Best Practices

  • Immutability for Value Types: Consider making value types immutable (their values cannot be changed after creation) when possible. This helps prevent unexpected side effects. Use `readonly` fields.
  • Defensive Copying for Reference Types: When passing reference types to methods, especially if the method might modify the object, consider creating a copy of the object to avoid unintended side effects.
  • Choose Appropriately: Use value types for simple data structures (e.g., coordinates, colors) where copying is inexpensive and frequent modification is not expected. Use reference types for more complex objects that are shared and modified throughout the application.

Interview Tip

Be prepared to explain the difference between value types and reference types, providing examples of each. Also, be ready to discuss the implications of their different storage mechanisms on memory management and program behavior. Discuss concepts like boxing and unboxing when converting between the two.

When to Use Them

  • Value Types: Use value types when you need to store small pieces of data and frequent copying is necessary, and you want independent copies. Good for representing primitive data or simple structures.
  • Reference Types: Use reference types when you need to share data between different parts of your program, when the data is complex, and when you want to avoid copying large amounts of data.

Memory Footprint

Value types typically have a smaller memory footprint than reference types because they directly store their data. However, if you have a large array of value types, the memory usage can still be significant. Reference types have the overhead of a pointer, plus the memory required to store the actual object data on the heap.

Alternatives: Immutable Reference Types

While reference types are mutable by default, you can create *immutable reference types*. This means that once the object is created, its properties cannot be changed. This can provide some of the benefits of value types (e.g., predictable behavior) while still using a reference type. To do so make the properties of the class read-only (with only a getter and no setter).

Pros and Cons - Value Types

Pros:
  • Direct access to data, leading to potentially faster access.
  • Independent copies prevent unintended side effects.
  • Generally smaller memory footprint for simple data.
Cons:
  • Copying can be expensive for large structs.
  • Cannot represent null values directly (without using `Nullable`).

Pros and Cons - Reference Types

Pros:
  • Sharing data between different parts of the program is easy.
  • Can represent null values.
  • Avoids copying large amounts of data.
Cons:
  • Potential for unintended side effects when multiple references modify the same object.
  • Garbage collection overhead.
  • Requires heap allocation, which can be slower than stack allocation.

← What are tuples in C#? What is a class and a struct in C#, and when to use each? →

FAQ

  • What is boxing and unboxing?

    Boxing is the process of converting a value type to a reference type (specifically, to an `object`). Unboxing is the reverse process – converting a reference type (that was previously boxed) back to a value type. Boxing and unboxing can have performance implications.
  • When should I use a struct instead of a class?

    Use a struct when you need a lightweight, immutable data structure to represent a single value. Structs are value types, so they are copied when assigned or passed as arguments. This makes them ideal for representing simple data structures like points or colors. Avoid structs for complex objects with significant data or behavior.
  • What is the `Nullable` type?

    `Nullable` (or `T?` shorthand) allows you to represent a value type that can also be null. This is useful when you need to indicate that a value is missing or undefined. For example, `int? age = null;`