C# OOP Mastery — From Quiz Answers to Production‑Grade Mental Models

C# OOP Mastery — From Quiz Answers to Production‑Grade Mental Models

Most C# interviews won’t ask you to build a whole enterprise system.

Instead, they quietly test whether you actually understand the mental model behind OOP fundamentals:

• What’s the difference between defining a class and creating an object?
• Why do methods represent behavior?
• Can C# inherit from multiple classes?
• Why do we use constructors (and when do we prefer object initializers)?
• What do access modifiers actually control?
• Why are record types “special” in modern C#?

In this post we’ll take quiz‑style questions and turn them into production patterns you can reuse in:

• code reviews
• architecture discussions
• technical interviews
• real .NET services

---

TL;DR — What you’ll learn

• The type vs instance mental model (class vs new)
• Why methods are behavior, not “just functions”
• The actual rule: single class inheritance, multiple interfaces
• Constructors, object initializers, and invariants
• Encapsulation with properties: get; set; (and how seniors restrict setters)
• Access modifiers: not “what exists”, but who can touch it
• protected reality (and when it becomes a design smell)
• Why record exists: value equality, immutability, and data modeling

---

1) “Which keyword creates an object?” — Definition vs Instantiation

Quiz version:

““What is the keyword or directive to create an object in C#?”

✅ Correct answer: new

Senior mental model

• class defines a type (a blueprint)
• new creates an instance (a runtime object on the managed heap, initialized by a constructor)

public class Person
{
    public string Name { get; }
    public Person(string name) => Name = name;
}

var p = new Person("Carlos"); // ✅ creates an object (instance)

Interview soundbite

“class defines the blueprint; new builds a real instance and runs the constructor.”

---

2) “What do methods define inside a class?” — Behavior

Quiz version:

“What do methods define within a class?”

✅ Correct answer: Behavior

Why this matters in production

Properties/fields represent state.

Methods represent behavior—the rules for changing that state.

public sealed class BankAccount
{
    public decimal Balance { get; private set; }

    public void Deposit(decimal amount)
    {
        if (amount <= 0) throw new ArgumentOutOfRangeException(nameof(amount));
        Balance += amount;
    }
}

Notice the pattern:

• state is protected
• state changes happen through methods
• methods enforce invariants

Interview soundbite

“Methods encode business rules. Properties hold data. Behavior protects invariants.”

---

3) “C# allows implementing only ONE interface” — False

Quiz version:

“C# allows the implementation of only ONE interface”

✅ Correct answer: False

Real rule (this is the one you must memorize)

• ✅ A class can implement multiple interfaces
• ❌ A class can inherit from only one base class

public sealed class ExportService : IDisposable, IAsyncDisposable, IHostedService
{
    public void Dispose() { /*...*/ }
    public ValueTask DisposeAsync() => ValueTask.CompletedTask;
    public Task StartAsync(CancellationToken ct) => Task.CompletedTask;
    public Task StopAsync(CancellationToken ct) => Task.CompletedTask;
}

Interview soundbite

“Single inheritance for classes, multiple inheritance for interfaces.”

---

4) “How do we initialize properties during creation?” — Constructor (and friends)

Quiz version:

“"How can we initialize the properties of an object during its creation?”

✅ Correct answer: Using the constructor

Senior nuance: constructor vs object initializer

Both can initialize values, but they serve different goals.

✅ Constructor = enforce invariants

Use it when an object must be created in a valid state.

public sealed class Order
{
    public Guid Id { get; }
    public string CustomerEmail { get; }

    public Order(Guid id, string customerEmail)
    {
        if (string.IsNullOrWhiteSpace(customerEmail))
            throw new ArgumentException("Email required.", nameof(customerEmail));

        Id = id;
        CustomerEmail = customerEmail;
    }
}

✅ Object initializer = ergonomics for optional fields

Good for DTOs or option bags.

var opts = new HttpClientOptions
{
    Timeout = TimeSpan.FromSeconds(10),
    Retries = 3
};

Interview soundbite

“Constructors establish invariants. Object initializers are ergonomic for optional configuration.”

---

5) “A class can be used as a property type in another class” — Composition

✅ Correct answer: True

This is composition: has‑a relationship (often better than inheritance).

public sealed class Address
{
    public string Street { get; init; } = "";
}

public sealed class Person
{
    public Address Address { get; init; } = new();
}

Why seniors prefer composition

Inheritance is tight coupling.

Composition keeps boundaries cleaner and enables substitution.

Interview soundbite

“Prefer composition: it’s easier to refactor and test than deep inheritance chains.”

---

6) “Access modifiers define the properties and methods a class has” — False

✅ Correct answer: False

Reality

Access modifiers define visibility, not existence.

• What exists = your class design
• Who can access it = access modifiers (public, private, protected, internal, etc.)

public sealed class User
{
    public string Email { get; private set; } = "";
    private string PasswordHash { get; set; } = "";
}

Interview soundbite

“Access modifiers answer: ‘who can touch this member?’ not ‘does it exist?’”

---

7) “Can C# inherit from multiple classes?” — No

✅ Correct answer: Only one class

public class Employee : Person // ✅
{
}

How we model “multiple inheritance” in C

• Use interfaces for capabilities
• Use composition for behavior reuse
• Use decorators and delegation for cross‑cutting concerns

Interview soundbite

“C# avoids multiple class inheritance—interfaces + composition give you flexibility without diamond problems.”

---

8) “What symbol assigns a value to a property?” — =

✅ Correct answer: =

person.Name = "Juan"; // assignment operator

Seniors care because assignment is often where invariants get violated.

That’s why you frequently see:

• private set;
• init;
• methods to mutate safely

---

9) protected access scope — True (but use carefully)

✅ Correct answer: True

protected means:

• accessible inside the declaring type
• accessible inside derived types

public class Base
{
    protected int Value;
}

public class Derived : Base
{
    public void Set() => Value = 10; // ✅ allowed
}

Senior warning

protected can create leaky inheritance designs where derived classes depend on fragile internal details.

Use it when:

• the base class is explicitly designed for extension
• you control the inheritance hierarchy
• you have a stable, documented template method model

---

10) Records matter because of value equality — True

✅ Correct answer: True

Why record exists

Records are designed for data modeling:

• value-based equality
• easy immutability
• structural comparison
• nice with DDD messages / events / DTOs

public record Person(string Name, int Age);

var p1 = new Person("Ana", 30);
var p2 = new Person("Ana", 30);

Console.WriteLine(p1 == p2); // ✅ true (value equality)

Interview soundbite

“Records are for data with value semantics—great for DTOs and domain events.”

---

11) Interface keyword — interface

✅ Correct answer: interface

public interface ILogger
{
    void Log(string message);
}

---

12) Class keyword — class

✅ Correct answer: class

public class Order { }

---

13) “Base concepts of OOP” — Class and Object

✅ Correct answer: class and object

Everything else (inheritance, polymorphism, abstraction, encapsulation) is built on that foundation.

---

14) Polymorphism in C# — Overriding (and interfaces)

✅ Correct answer: Overwrite

public abstract class Animal
{
    public abstract string Speak();
}

public sealed class Dog : Animal
{
    public override string Speak() => "Bark";
}

---

15) Abstraction statement — True

✅ Correct answer: True

Abstraction defines what to do, without specifying how:

• interfaces
• abstract classes

---

16) “What to consider for a property?” — access level, type, name

✅ Correct answer: A. Access level, type and name

Example:

public string Name { get; private set; } = "";

---

17) Encapsulation keywords — get; set;

✅ Correct answer: get; set;

Senior upgrade

Encapsulation isn’t “public get/set everywhere”. It’s controlling mutation.

public sealed class Customer
{
    public string Email { get; private set; }

    public Customer(string email)
    {
        // validate and normalize
        Email = email.Trim().ToLowerInvariant();
    }

    public void ChangeEmail(string newEmail)
    {
        Email = newEmail.Trim().ToLowerInvariant();
    }
}

---

Final Thoughts — Why these “basic” answers matter

These questions are not trivia. They map directly to:

• SOLID (encapsulation + abstractions + substitutability)
• Clean Architecture (boundaries + composition)
• Dependency Injection (interfaces + object graph creation)
• Maintainability (invariants and controlled mutation)

If you can explain these mental models clearly, you’re not just “knowing C#” — you’re reasoning like an engineer who can build systems that survive change.

---

✍️ Written by Cristian Sifuentes — building resilient .NET systems, teaching teams how to reason about OOP, boundaries, and clean architecture.