Interview Q&A

Answer: Virtual calls resolved at runtime. Minor overhead due to vtable lookups, generally negligible.

What interviewers expect

• A clear definition tied to OOP in C# OOP projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production C# OOP application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in C# OOP architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

Answer: Yes, interfaces can define event contracts for publishers/subscribers. Enables decoupling of event producers and consumers.

What interviewers expect

• A clear definition tied to OOP in C# OOP projects
• Trade-offs (performance, maintainability, security, cost)
• When you would and would not use it in production

Real-world example

In a production C# OOP application, teams apply this when handling user-facing features or integration boundaries. For example, you might use it during a sprint where reliability and observability matter—logging metrics, validating edge cases, and documenting the decision in an ADR so future developers understand why the approach was chosen.

How to explain in the interview

1. Define the concept in one or two sentences.
2. Context — where it fits in C# OOP architecture.
3. Example — a specific project, bug, or performance win.
4. Trade-off — what you gain vs what you sacrifice.

Tip: Practice aloud on Toolliyo mock interview or the Interview Q&A section before your real interview.

• Duck typing: "If it looks like a duck and quacks like a duck, it is a duck."
• Behavior is based on method/property availability, not type inheritance.
• C# does not support full dynamic duck typing, but interfaces enable a similar

concept by relying on contract-based behavior.

• Dynamic types in C# (dynamic) can also simulate duck typing.

interface IFlyable { void Fly(); }
void MakeItFly(IFlyable obj) => obj.Fly(); // Any object

implementing IFlyable works

• Yes, C# 8 introduced private methods in interfaces.
• Purpose: share implementation among default interface methods without

exposing them publicly.

interface ILogger
{
void Log(string message) => LogInternal(message);
private void LogInternal(string msg) => Console.WriteLine(msg);
}

• Allows interfaces to provide default method implementations.
• Reason: Enables adding new methods to interfaces without breaking existing

implementations.

interface IPrinter
{

void Print(string msg);

void PrintInfo(string msg) => Console.WriteLine("Info: " + msg);

// Default

}

• Abstract classes often define base contracts or template methods for patterns:
• Abstract Factory: Defines abstract methods to create families of objects.
• Strategy Pattern: Abstract class defines a common interface for

interchangeable algorithms.

bstract class PaymentStrategy

{
public abstract void Pay(decimal amount);
}
class CreditCardPayment : PaymentStrategy
{
public override void Pay(decimal amount) =>

Console.WriteLine($"Paid {amount} by credit card");

}

• Encapsulation and abstraction hide implementation details, exposing only

necessary interfaces.

• Polymorphism allows replaceable modules, facilitating microservices

independently deployed and evolved.

• SOLID principles and interface-based contracts promote loose coupling and

utonomous service design.