Value types and reference types

b = a copies a Point struct, so setting b.X to 9 leaves a.X at 1. Declare Point as a class instead, and the same two lines change a.X to 9 as well, because a and b now name one object. Every C# type is one of two kinds, value typesvalue type: A type whose variables hold the value itself, such as int, a struct or an enum. Assigning or passing such a value copies it, so a change to the copy never reaches the original. and reference typesreference type: A type whose variables hold a reference to an object, such as a class, string or array. Assigning or passing such a variable copies the reference, so both variables lead to the same object., and the kind decides what an assignment, an argument or a list entry copies.

You will predict what each assignment and call copies, catch an object shared by accident, and tell value types from reference types by what they copy, not by where they live.

Assigning a struct copies its data; assigning a class copies a reference

A variable of a value type holds its data, and assignment copies that data. A variable of a reference type holds a reference to an object, and assignment copies the reference, so both variables lead to the same object. This program runs the same three lines on a struct and on a class:

using System.Globalization;

CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;

// The same two fields, once in a struct and once in a class.
PointStruct a = new() { X = 1, Y = 2 };
PointStruct b = a;
b.X = 9;
Console.WriteLine($"struct: a = {a}, b = {b}");

PointClass c = new() { X = 1, Y = 2 };
PointClass d = c;
d.X = 9;
Console.WriteLine($"class:  c = {c}, d = {d}");
Console.WriteLine($"c and d are one object: {ReferenceEquals(c, d)}");

struct PointStruct
{
    public int X;
    public int Y;

    public override readonly string ToString() => $"({X}, {Y})";
}

class PointClass
{
    public int X;
    public int Y;

    public override string ToString() => $"({X}, {Y})";
}

struct: a = (1, 2), b = (9, 2)
class:  c = (9, 2), d = (9, 2)
c and d are one object: True

b = a copied both fields of the struct, so setting b.X to 9 changed only b. d = c copied a reference, so d.X = 9 changed the one object that c names too, and ReferenceEquals(c, d) confirmed that there is only one. Step through what each line did:

Microsoft’s reference states the same rule: a variable of a value type contains an instance of the type, while a variable of a reference type contains a reference to one.

A method gets a copy too: of the value, or of the reference

Passing an argument is an assignment to the parameter, so the same rule applies. By default C# passes every argument by value: the method gets a copy of a struct, or a copy of a reference. This program calls the same Shift code with a struct and with a class, then replaces a parameter, changes an array and changes a string:

using System.Globalization;

CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;

PointStruct s = new() { X = 1, Y = 2 };
Moves.Shift(s);
Console.WriteLine($"after Shift(struct):    s = {s}");

PointClass c = new() { X = 1, Y = 2 };
Moves.Shift(c);
Console.WriteLine($"after Shift(class):     c = {c}");

Moves.Replace(c);
Console.WriteLine($"after Replace(class):   c = {c}");

int[] marks = [40, 55, 70];
Moves.AddGrace(marks);
Console.WriteLine($"after AddGrace(int[]):  marks = {string.Join(", ", marks)}");

string city = "pune";
Moves.Shout(city);
Console.WriteLine($"after Shout(string):    city = {city}");

static class Moves
{
    // The same code twice: it changes the method's own copy of a struct, or the one object a class reference names.
    public static void Shift(PointStruct p) => p.X += 10;

    public static void Shift(PointClass p) => p.X += 10;

    // Assigning to the parameter changes only the method's own variable.
    public static void Replace(PointClass p) => p = new PointClass { X = 100, Y = 100 };

    public static void AddGrace(int[] values)
    {
        for (int i = 0; i < values.Length; i++)
        {
            values[i] += 5;
        }
    }

    public static void Shout(string text) => text = text.ToUpperInvariant();
}

struct PointStruct
{
    public int X;
    public int Y;

    public override readonly string ToString() => $"({X}, {Y})";
}

class PointClass
{
    public int X;
    public int Y;

    public override string ToString() => $"({X}, {Y})";
}

after Shift(struct):    s = (1, 2)
after Shift(class):     c = (11, 2)
after Replace(class):   c = (11, 2)
after AddGrace(int[]):  marks = 45, 60, 75
after Shout(string):    city = pune

Shift(s) changed the method’s own copy, so s stayed (1, 2), while Shift(c) followed its copy of the reference to the caller’s object, which became (11, 2). Replace(c) gave its parameter a new object, which changed only the method’s variable. An array is a reference type, so AddGrace changed the caller’s marks, and Shout left city alone, because ToUpperInvariant returns a new string.

The ref, out and in modifiers change this rule; the module on methods covers them.

Which types are value types, and which are reference types

Type.IsValueType says which kind a type is:

using System.Globalization;

CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;

// Type.IsValueType says which of the two kinds a type is.
(string Name, Type Type)[] types =
[
    ("int", typeof(int)),
    ("double", typeof(double)),
    ("decimal", typeof(decimal)),
    ("bool", typeof(bool)),
    ("char", typeof(char)),
    ("DateTime", typeof(DateTime)),
    ("DayOfWeek, an enum", typeof(DayOfWeek)),
    ("(int, string), a tuple", typeof((int, string))),
    ("int?", typeof(int?)),
    ("PointStruct", typeof(PointStruct)),
    ("string", typeof(string)),
    ("int[]", typeof(int[])),
    ("object", typeof(object)),
    ("List<int>", typeof(List<int>)),
    ("Action, a delegate", typeof(Action)),
    ("PointClass", typeof(PointClass)),
    ("Booking, a record", typeof(Booking)),
    ("Fare, a record struct", typeof(Fare)),
];
foreach ((string name, Type type) in types)
{
    Console.WriteLine($"{name,-24} {(type.IsValueType ? "value type" : "reference type")}");
}

// string is a reference type that behaves like a value: no change shows through another variable.
Console.WriteLine();
string city = "Pune";
string copy = city;
copy += " Junction";
Console.WriteLine($"city = {city}, copy = {copy}");
string built = new(['P', 'u', 'n', 'e']);
Console.WriteLine($"built == city: {built == city}, one object: {ReferenceEquals(built, city)}");

struct PointStruct
{
    public int X;
    public int Y;
}

class PointClass
{
    public int X;
    public int Y;
}

record Booking(string Pnr);

record struct Fare(decimal Amount);

int                      value type
double                   value type
decimal                  value type
bool                     value type
char                     value type
DateTime                 value type
DayOfWeek, an enum       value type
(int, string), a tuple   value type
int?                     value type
PointStruct              value type
string                   reference type
int[]                    reference type
object                   reference type
List<int>                reference type
Action, a delegate       reference type
PointClass               reference type
Booking, a record        reference type
Fare, a record struct    value type

city = Pune, copy = Pune Junction
built == city: True, one object: False

The numeric types, bool, char, DateTime, enums, tuples such as (int, string), nullable value types such as int? and every struct are value types. string, arrays, object, collections such as List<int>, delegates, classes and records are reference types, while record struct declares a record that is a value type. An array is a reference type even when its elements are numbers. The kind matters most for the types you did not write: a DateTime passed to a method is a copy, while a List<int> passed the same way is the caller’s own list.

string is the reference type that behaves like a value. copy += " Junction" made a new string and left city unchanged, and built == city was true although ReferenceEquals showed two objects, because == on strings compares the text.

Accidental sharing, reproduced and fixed with deep copies Pro: opens with a Pro, Premium or Ultimate pass

Where values really live: the heap, the stack and the JIT, measured Pro: opens with a Pro, Premium or Ultimate pass

Equality, defaults and null for each kind, compared Pro: opens with a Pro, Premium or Ultimate pass

Practise: predict, then run

Then answer the questions on copies, arguments and the two kinds of types, which begin where your answers so far are weakest:

Interview questions

Fresher · What is the difference between a value type and a reference type in C#?

A variable of a value type, such as int, double, a struct or an enum, holds the value itself, so assignment and argument passing copy the value, and a change to the copy never reaches the original. A variable of a reference type, such as a class, string, an array or a delegate, holds a reference to an object, so assignment copies the reference and both variables lead to the same object: a change made through one shows through the other. string is a reference type that cannot change, so it behaves like a value. Where the memory lives is not the defining difference; what a copy copies is.

Key takeaways

• A variable of a value type holds its data, and assignment copies the data, so b = a gives two separate structs.
• A variable of a reference type holds a reference, and assignment copies the reference, so d = c gives two names for one object.
• Arguments are passed by value: a method gets a copy of a struct or a copy of a reference, so it can change the caller’s object but cannot replace it.
• Numbers, bool, char, enums, tuples and structs are value types, while classes, records, arrays, delegates and string are reference types, and string behaves like a value because it never changes.