The class
A class describes a kind of object. Account.cs says every Account has two fields, Owner and Balance, plus a constructor and a method, Deposit. The class itself holds no account data: it is a blueprint, and a type.
Making an object
Line 1 runs new Account("Ada"). First, new asks the runtime for memory on the heap, enough for one Account object. Every field starts at its default value: Owner is null and Balance is 0.
Next the constructor runs: the special method named after its class, with no return type. It receives "Ada" as o and sets Owner = o. A constructor's job is to give each new object a valid start.
new hands back a reference to the object, not the object itself. var a stores that reference, drawn here as #1. The variable stays small; the object stays on the heap, and a refers to it.
a.Deposit(50) follows a to object #1 and runs Deposit there. The method's code lives once, in the class. Inside it, Balance means this object's Balance (this.Balance in full), so it goes from 0 to 50.
References and sharing
var b = a copies the reference, not the object. Now a and b both hold #1: two variables, one object. Nothing new appears on the heap, because only new makes objects.
b.Deposit(25) follows b to the same object, #1, so Balance goes from 50 to 75. Reading a.Balance now also gives 75: a and b are two names for one object.
Line 5 runs new again, so a second, separate Account appears: #2, with its own fields. The constructor sets its Owner to "Bo"; its Balance stays 0. Objects share the class's code, never each other's data.
Line 6 follows a to object #1, reads its Balance and prints 75. The deposit made through b shows up through a, because both variables lead to the same object.
One class, Account, is the blueprint and the type. Each new made a separate object with its own fields. Variables hold references: a and b share #1, c holds #2. When nothing refers to an object, the garbage collector can free it.
What happens
// step 1/10 · blueprint
1 class Account { a new type, named Account
2 public string Owner; field: every Account has an Owner
3 public int Balance; field: and a Balance
4 public Account(string o) the constructor: named after the class
5 => Owner = o; sets this object's Owner
6 public void Deposit(int x) a method
7 => Balance += x; adds x to this object's Balance
8 } end of the class
field a variable that belongs to each object
public code outside the class may use it (members are private by default)
The figure writes a reference as #1 or #2. A real reference is the object's address in memory, which C# never shows you; you only follow it with the dot, as in a.Balance. Here a, b and c are local variables of the top-level statements, so they normally sit in the method's stack frame. Where a local lives is a runtime detail; what matters is that it holds a reference, not the object.