What is the difference between value types and reference types in C#? Where do they live (stack or heap), how is a struct different from a class, and how does it affect performance?

Say it out loud, then check

One billing run, every idea

The BMW FS nightly billing job, in time order. Each step names where the data lives and what gets copied.

The story

1. Before

   A finance quote is a dealer's offer to a BMW FS customer: the car's price and the months to pay. In code it is a Quote object. A developer added a "What if 48 months?" button to the dealer portal's API. It took the quote the customer had been sent, made a second variable for the preview, and changed the term on the preview.

   senton the stack

   Quote objecton the heap: 36 months

   1/4Before: the customer was sent a quote for 36 months. The code holds it in sent.The preview code writes Quote preview = sent; It looks like a copy of the quote.It sets the preview to 48 months. The customer's quote says 48 too: one object, two names.Fix: the preview is a new object. Two objects, two terms; the sent quote stays at 36.

   BackPlayNext
2. Why it had to change

   Quote is a class, which makes it a reference type: a Quote variable holds only the address of the object (a reference), not the quote itself. So = copied the address. An int is a value type: its variable holds the number itself, so = copies the number. Same =, two different results, and the compiler can't warn you, because both are perfectly legal code.

3. How it works now

   Here is what .NET does with memory when an object is built and then changed. The stack is the method's own space for its variables; the heap is where new puts objects. (52_000m means 52,000 as a decimal.)

   Your codeone line at a time

   Stackthe variables

   Heapthe objects

   new Quote

   sent: the address

   1/2new Quote(52_000m, 36) builds the quote on the heap and returns its address.preview holds the same address. preview.TermMonths = 48 changes the one quote.

   BackPlayNext
4. What we gained

   Once you know which kind a type is, you can predict what = and a method call will do. The rest of the card shows where each kind lives, struct vs class, and what each costs in speed.

In the lending API

The three copies. Each marked line is one =. "See it" (section 1) shows what each one copied.

Only the key lines are shown; Deep walks the whole file.

The code, file by file

Three xUnit tests (a test tool for .NET) that prove what = copies, and the two types they use. Tap Next to walk the diagram with the code.

What they ask next

The follow-ups interviews really ask. Answer out loud, then tap to check.

• ReportedDo value types always live on the stack?

  No. A value-type local variable usually does. But a value type that is a field of a class lives inside that object, on the heap; a boxed value is on the heap; and a local that a lambda captures, or that an async method keeps across an await, is moved to the heap by the compiler. What always holds is the copy rule: = copies a value type's data.

  public class Quote
  {
    // inside the object: heap
    public decimal Price;
  }
   
  void Run()
  {
    // local: stack
    decimal p = 52_000m;
  }

  Next questions, in Deep →EPAM: stack vs heap
• ReportedWhat is boxing, and why does it cost?

  Boxing is putting a value type where an object or an interface is expected. .NET makes a new object on the heap and copies the value into it; unboxing, a cast back, copies it out again. Each box is an allocation the garbage collector must clean up later, so boxing inside a loop over millions of rows adds up. Generic code like List<int> stores the values as they are, with no boxing.

  int months = 36;
  // boxing: heap copy
  object box = months;
  months = 48;
  // unboxing: 36
  int back = (int)box;
   
  // list of int: no boxing
  var terms = new List<int> { 36, 48 };

  Next questions, in Deep →Thinknext Technologies: value vs reference and performance
• ReportedWhen would you choose a struct over a class?

  When the type is one small value that never changes and is used in large numbers: a mileage reading, a date range. Microsoft's guideline says to avoid a struct unless it is one value, under 16 bytes, immutable and rarely boxed. Everything with an identity that changes, like a contract or an instalment, is a class. And I make every struct a readonly struct.

  Next questions, in Deep →r/csharp, 2026: difference between a class and a struct

Follow-up tree

Answer, then open the next level. That is the order an interviewer digs in.

Reporteda candidate was asked Intervieweran interviewer asks it

• ReportedDo value types always live on the stack?

  No. A value-type local variable usually does. But a value type that is a field of a class lives inside that object, on the heap; a boxed value is on the heap; and a local that a lambda captures, or that an async method keeps across an await, is moved to the heap by the compiler. What always holds is the copy rule: = copies a value type's data.

  public class Quote
  {
    // inside the object: heap
    public decimal Price;
  }
   
  void Run()
  {
    // local: stack
    decimal p = 52_000m;
  }

  EPAM: stack vs heap
• ReportedWhat is boxing, and why does it cost?

  Boxing is putting a value type where an object or an interface is expected. .NET makes a new object on the heap and copies the value into it; unboxing, a cast back, copies it out again. Each box is an allocation the garbage collector must clean up later, so boxing inside a loop over millions of rows adds up. Generic code like List<int> stores the values as they are, with no boxing.

  int months = 36;
  // boxing: heap copy
  object box = months;
  months = 48;
  // unboxing: 36
  int back = (int)box;
   
  // list of int: no boxing
  var terms = new List<int> { 36, 48 };

  Thinknext Technologies: value vs reference and performance
  • Where does boxing hide in real code?

    Using a struct through an interface it implements, passing a value type to an object parameter, old collections like ArrayList, and logging calls such as LogInformation("{Amount}", amount), whose arguments are an object array, so each value-type argument is boxed. I find them with a profiler's allocation view or BenchmarkDotNet's memory diagnoser, not by reading code.

• ReportedWhen would you choose a struct over a class?

  When the type is one small value that never changes and is used in large numbers: a mileage reading, a date range. Microsoft's guideline says to avoid a struct unless it is one value, under 16 bytes, immutable and rarely boxed. Everything with an identity that changes, like a contract or an instalment, is a class. And I make every struct a readonly struct.

  r/csharp, 2026: difference between a class and a struct
  • Can a struct inherit from another type?

    No. A struct can't inherit from a class or another struct, and nothing can inherit from a struct. It can implement interfaces, but using it through the interface boxes it.

  • What does readonly struct add?

    The compiler requires every field to be read-only and refuses any change after the constructor: reading.Miles = 5 is a compile error. So a lost change on a copy can't happen, and .NET can skip the hidden safety copies it makes of a normal struct in some places. It is only one level deep: if a field points to an object, like a List, that object can still change.

    Walk the incident →
  • What is a record struct?

    A struct where the compiler writes value equality and a ToString for you, and supports with (copy with one value changed). readonly record struct Mileage(int Miles) is a small immutable value in one line. A plain record is a class.

• Why not…If I pass a class to a method, is it passed by reference?

  Not quite. Everything is passed by value by default; for a class, the value is the reference. So the method can change the caller's object (the first bug below), but if it points its parameter at a new object, the caller doesn't see that.

  void Change(Quote q)
  {
    q.TermMonths = 60; // caller sees 60
  }
   
  void Replace(Quote q)
  {
    q = new Quote(1m, 12); // caller
                 // doesn't see it
  }

  See the bug →
  • What do ref, out and in do?

    They pass the variable itself instead of a copy. ref: the method can read it and point it at a new value or object. out: the method must give it a value, like int.TryParse(text, out int months). in: read-only, used to pass a big struct without copying it.

• Is string a value type? It behaves like one.

  No, it is a reference type. It feels like a value because it can never be changed (every "change" builds a new string) and == compares the text. The references page shows it.

• Two structs with the same values: are they equal?

  Equals says yes: a struct's default Equals compares every field's value, which is slow when the struct holds a reference type, so Microsoft says to override it then. == doesn't compile on your own struct until you write it (error CS0019). A record struct gives you fast Equals and ==. Two class objects with the same values are not equal by default: classes compare references.

• Can a value type be null? What is int?

  A plain value type can't: its default is all zeros. int? is short for Nullable<int>, a struct that holds a value or "no value"; HasValue tells you which. Use it whenever "nothing yet" is a real state, like a payment date.

  See the bug →

Production bugs, and how to tell them

Each one: what you see, why, the fix in code, and the line to say.

• Opening the payoff quote lowered the balance on screen

  UDC Finance customer support ticket:
  "After I opened the payoff quote, my balance showed $412 less. On reload it was back."
  (no exception, no error log)

  Cause

  The account summary call built two numbers from one Contract object: the balance, and what it would cost to pay the contract off today. The payoff helper took the Contract as a parameter and did contract.Balance -= discount to work out its number. A class parameter is a copy of the reference, so the helper changed the very object the summary then read the balance from.

  Fix

  The helper keeps its working number in a local decimal, a value type, and never writes to the contract. A test calls it and checks the contract's balance is unchanged.

  BeforeAfterPayoffTests.cs

  Diagram · step 2Before: the helper gets a copy of the address, so it points at the same contract.Show diagram

  Summarybuilds the account page

  PayoffTodaythe helper

  Contract objectBalance 18,400

  1public decimal PayoffToday(2 Contract contract)3{4 decimal discount = EarlyDiscount(contract);5 contract.Balance -= discount;6 return contract.Balance;7}

  Before · PayoffCalculator.cs · line 2 · 1 of 2contract is a copy of the caller's reference: the same object as the summary's.

  BackNext line

  Say it

  C# passes a copy of the variable, and for a class that copy is a reference, so our payoff helper changed the caller's contract while it calculated. Now helpers work on local values and never change their inputs, and a test proves the balance stays the same.

• Statements said the last payment was on 1 January 0001

  BMW FS customer statement (PDF), new contracts:
  "Last payment received: 01/01/0001"
  (no exception, no error log)

  Cause

  StatementLine had public DateTime LastPaidOn. DateTime is a value type, and a value type can never be null. A new contract with no payment yet got the default value, all zeros, which for a DateTime is 1 January 0001, and the PDF printed it.

  Fix

  Make it DateTime?, a nullable value type (Nullable<DateTime>) that can also hold "no value". The PDF prints "No payment yet" when HasValue is false. A test builds a statement for a new contract and checks the text.

  BeforeBeforeAfterAfter

  Diagram · step 1Before: LastPaidOn is a DateTime, a value type. No payment yet, so it holds its default.Show diagram

  StatementLineLastPaidOn = 01/01/0001

  1public DateTime LastPaidOn { get; set; }

  Before · StatementLine.cs · line 1 · 1 of 1Can never be empty. If nothing sets it, it is 1 January 0001.

  BackNext file

  Say it

  A value type can't be null, so a missing date showed as its default, 1 January 0001. We made the field a nullable DateTime, so "no payment yet" is a real state the code must handle, and a test covers a new contract.

Traps

• Don't sayValue types live on the stack, reference types on the heap.SayValue-type locals usually do. A value type inside a class object lives in that object, on the heap. What always holds is that = copies a value type's data.
• Don't sayClasses are passed by reference.SayEverything is passed by value by default; for a class the value is the reference. The method can change the object but can't replace the caller's variable without ref.
• Don't sayStructs are faster, so use them for speed.SaySmall, immutable structs save allocations. Big or changeable ones cost copies and lose updates. Measure with BenchmarkDotNet first.
• Don't saystring is a value type.SayIt is a reference type that can't be changed, and == compares the text, so it behaves like a value.

Traps

What should you say instead? Tap to check.

• Don't sayValue types live on the stack, reference types on the heap.

  Say instead

  Value-type locals usually do. A value type inside a class object lives in that object, on the heap. What always holds is that = copies a value type's data.

• Don't sayClasses are passed by reference.

  Say instead

  Everything is passed by value by default; for a class the value is the reference. The method can change the object but can't replace the caller's variable without ref.

• Don't sayStructs are faster, so use them for speed.

  Say instead

  Small, immutable structs save allocations. Big or changeable ones cost copies and lose updates. Measure with BenchmarkDotNet first.

• Don't saystring is a value type.

  Say instead

  It is a reference type that can't be changed, and == compares the text, so it behaves like a value.