OOP in C#

In simple words#

Learning objectives#

• Recognise each OOP concept in idiomatic C#
• Combine an abstract class with an interface
• Use sealed, protected and records appropriately
• Read and write a complete small C# domain model

Explanation#

Encapsulation: Balance has a protected setter, so only account classes change it, and only through Deposit and TryWithdraw.

Abstraction and the template method: Account.TryWithdraw is written once and calls the abstract CanWithdraw, which each account type decides.

Inheritance and polymorphism: SavingsAccount and CurrentAccount inherit from Account; the loop treats them all as Account and each applies its own rule.

Interfaces: only savings accounts implement IInterestBearing — a capability, not a parent.

sealed stops further inheritance where it is not designed for; a record models an immutable transaction with value equality and free ToString.

Primary constructors (class SavingsAccount(string owner, decimal opening)) keep the code short; they are C# 12 syntax.

Code example: Bank accounts using every OOP concept#

1var accounts = new List<Account>
2{
3    new SavingsAccount("Asha", 6000m),
4    new CurrentAccount("Ravi", 5000m, overdraftLimit: 2000m),
5};
6

7foreach (var account in accounts)
8{
9    account.Deposit(1000m);
10    bool ok = account.TryWithdraw(7500m);
11    Console.WriteLine(
quot;{account.Owner,-5} {account.GetType().Name,-15} withdraw 7500: {(ok ? "OK" : "declined")}, balance {account.Balance}");
12}
13

14var savings = (IInterestBearing)accounts[0];
15Console.WriteLine(
quot;Interest this year: {savings.YearlyInterest()}");
16Console.WriteLine(new Transaction("Ravi", -7500m));
17

18public interface IInterestBearing
19{
20    decimal YearlyInterest();
21}
22

23public abstract class Account(string owner, decimal opening)
24{
25    public string Owner { get; } = owner;
26    public decimal Balance { get; protected set; } = opening;
27

28    public void Deposit(decimal amount)
29    {
30        if (amount <= 0) throw new ArgumentException("Amount must be positive");
31        Balance += amount;
32    }
33

34    public bool TryWithdraw(decimal amount)
35    {
36        if (!CanWithdraw(amount)) return false;
37        Balance -= amount;
38        return true;
39    }
40

41    protected abstract bool CanWithdraw(decimal amount);
42}
43

44public sealed class SavingsAccount(string owner, decimal opening)
45    : Account(owner, opening), IInterestBearing
46{
47    protected override bool CanWithdraw(decimal amount) => amount <= Balance;
48    public decimal YearlyInterest() => Math.Round(Balance * 0.04m, 2);
49}
50

51public sealed class CurrentAccount(string owner, decimal opening, decimal overdraftLimit)
52    : Account(owner, opening)
53{
54    protected override bool CanWithdraw(decimal amount) => amount <= Balance + overdraftLimit;
55}
56

57public record Transaction(string Owner, decimal Amount);

Asha  SavingsAccount  withdraw 7500: declined, balance 7000
Ravi  CurrentAccount  withdraw 7500: OK, balance -1500
Interest this year: 280.00
Transaction { Owner = Ravi, Amount = -7500 }

This example is illustrative. Copy or download it and run it in your own environment; the expected output is shown above.

Step-by-step explanation#

1. Both accounts are stored as the base type Account — polymorphism.
2. Deposit and TryWithdraw are shared code in the abstract base; CanWithdraw is the abstract blank.
3. Savings declines because 7500 is more than its 7000 balance; Current allows it thanks to the 2000 overdraft.
4. Balance has a protected setter: Program cannot write account.Balance = 1000000.
5. Only SavingsAccount implements IInterestBearing, so interest is a capability, not part of every account.
6. Transaction is a record: immutable, with a readable ToString for logs.

Real-world use case#

Common mistakes#

Best practices#

• Protect state with private or protected setters
• Put shared rules in an abstract base and varying rules in overrides
• Use interfaces for optional capabilities
• Use records for immutable data and DTOs

Remember this#

Practice exercise#

1var fd = new FixedDepositAccount("Meera", 10000m);
2Console.WriteLine(fd.TryWithdraw(100m));    // False
3Console.WriteLine(fd.YearlyInterest());    // 700.00
4

5public interface IInterestBearing { decimal YearlyInterest(); }
6

7public abstract class Account(string owner, decimal opening)
8{
9    public string Owner { get; } = owner;
10    public decimal Balance { get; protected set; } = opening;
11    public bool TryWithdraw(decimal amount)
12    {
13        if (!CanWithdraw(amount)) return false;
14        Balance -= amount;
15        return true;
16    }
17    protected abstract bool CanWithdraw(decimal amount);
18}
19

20public sealed class FixedDepositAccount(string owner, decimal opening)
21    : Account(owner, opening), IInterestBearing
22{
23    protected override bool CanWithdraw(decimal amount) => false;
24    public decimal YearlyInterest() => Math.Round(Balance * 0.07m, 2);
25}

Mini quiz#

Want more? Practise all OOP Concepts MCQs · OOP Concepts interview questions

Related topics#

My notes#

Saved in this browser.