Question 1

What are the SOLID principles? Explain each briefly.

Accepted Answer

S ingle Responsibility: one reason to change per class. O pen/Closed: extend behaviour by adding code, not modifying existing code. L iskov Substitution: subclasses must work anywhere the base class works. I nterface Segregation: small client-specific interfaces instead of a fat one. D ependency Inversion: high- and low-level modules depend on abstractions; inject dependencies. Follow with one concrete example from your own project, e.g. payment providers behind IPaymentGateway , registered in DI — that s OCP and DIP.

Question 2

Give a real example of the Single Responsibility Principle.

Accepted Answer

In short: An InvoiceService that calculates totals, writes to SQL and sends email has three reasons to change. Split it into InvoiceCalculator , IInvoiceRepository and IInvoiceSender , with a small workflow class orchestrating them. Now an SMTP-to-SendGrid change touches only the sender, and each part has focused unit tests.

Question 3

How do you implement the Open/Closed Principle in C#?

Accepted Answer

In short: Through abstractions and polymorphism : define an interface ( IDiscountRule , IExportFormatter ), implement each variant as its own class, and let the consumer receive IEnumerable IDiscountRule from DI. Adding a variant means a new class and registration; no existing, tested code changes. Other OCP tools: Strategy, Decorator, middleware, filters, events.

Question 4

Explain the Liskov Substitution Principle with the Rectangle–Square example.

Accepted Answer

In short: Mathematically a square is a rectangle, but if Square overrides Width / Height setters to keep sides equal, code written for Rectangle (set width 5, height 4, expect area 20) breaks and gets 16. The subtype changed the base s behaviour, which violates LSP. Fix: don t inherit; make both implement IShape with an Area , or make them immutable. Practical LSP violations: overrides throwing NotSupportedException , or a read-only collection deriving from a writable one.

Question 5

What is the difference between Dependency Inversion, Dependency Injection and Inversion of Control?

Accepted Answer

In short: DIP is the design principle : depend on abstractions. IoC is the broader concept that control of object creation and flow is handed to a framework or container. DI is a technique to achieve IoC/DIP: dependencies are supplied from outside (constructor injection preferred) rather than created with new inside the class. ASP.NET Core s built-in container is an IoC container that performs DI.

Question 6

What are the service lifetimes in ASP.NET Core DI and what is a captive dependency?

Accepted Answer

In short: Transient (new each time), Scoped (one per request/scope), Singleton (one for the app). A captive dependency happens when a longer-lived service holds a shorter-lived one — e.g. a singleton injecting a scoped DbContext . The DbContext then lives forever and is shared across threads, which causes concurrency exceptions and stale data. Fix: make the consumer scoped, or inject IServiceScopeFactory and create a scope per operation (common in BackgroundService ).

Question 7

Give an Interface Segregation example from .NET itself.

Accepted Answer

In short: IEnumerable T (iterate only) → IReadOnlyCollection T (+Count) → IReadOnlyList T (+indexer) vs ICollection T / IList T (mutation). A method that only reads should accept IEnumerable T / IReadOnlyList T . Similarly, ASP.NET Core splits IConfiguration and IOptions T , and logging into ILogger and ILoggerFactory .

Question 8

Is it OK to violate SOLID sometimes?

Accepted Answer

In short: Yes. SOLID is a set of guidelines, not laws. Over-applying them creates interface for everything designs, needless indirection and many tiny files. Apply them where change is likely or testing needs seams (external services, business rules that vary). For stable, simple code, KISS and YAGNI win. Good answer: I refactor towards SOLID when a second variant or a test need appears.

Question 9

Which design patterns support which SOLID principles?

Accepted Answer

In short: Strategy, Decorator, Template Method, Observer → OCP . Adapter, Facade → DIP/ISP (wrap details behind your own abstraction). Factory/Abstract Factory → DIP (hide creation). Repository → DIP/SRP . Chain of Responsibility/middleware → SRP + OCP . Composite → LSP (leaf and composite are interchangeable).

Question 10

How does Clean Architecture apply the Dependency Inversion Principle?

Accepted Answer

In short: The Domain and Application layers define interfaces (ports) such as IOrderRepository or IEmailSender . The Infrastructure layer implements them with EF Core, SMTP or Azure. The API project (composition root) wires them together. Source-code dependencies point inward, so business rules don t reference EF Core or ASP.NET. You can test them with in-memory fakes and swap infrastructure without touching them.

Question 11

What is the Stable Dependencies / Stable Abstractions principle?

Accepted Answer

In short: They are package-level principles from Robert C. Martin. Stable Dependencies: depend in the direction of stability (packages that many others rely on should change rarely). Stable Abstractions: stable packages should be abstract (interfaces), so they can be extended without modification. Together they explain why the domain/interfaces project sits at the centre and has no dependencies.

Question 12

Your NotificationService sends email via SMTP using new SmtpClient() inside the method. The business now wants SMS and WhatsApp too, and tests keep sending real emails. What do you change?

Accepted Answer

Introduce INotificationChannel { Task SendAsync(Notification n); } (DIP). Implement EmailChannel (SMTP or SendGrid), SmsChannel and WhatsAppChannel (OCP: one class per channel). Inject IEnumerable INotificationChannel into NotificationService and select by the user s preference. Move settings to IOptions SmtpSettings . In unit tests, use a fake channel, so no real emails are sent. Optional: a decorator for retry/logging (OCP), and a queue so sending doesn t block the request.

Question 13

A code review shows if (shape is Circle) ... else if (shape is Square) ... in five places. What principle is violated and how do you fix it?

Accepted Answer

In short: It violates OCP (every new shape edits five places) and usually LSP/polymorphism . Move the behaviour into the types: abstract double Area() (or an interface method) implemented by each shape, and callers just call shape.Area() . If the operation shouldn t live in the shape (e.g. rendering), use the Visitor pattern, or a dictionary of strategies keyed by type.

Question 14

A background service crashes with "Cannot consume scoped service from singleton". Explain and fix.

Accepted Answer

In short: AddHostedService registers hosted services as singletons. Injecting a scoped service (like DbContext ) into the constructor is a captive dependency, so the container refuses it. Inject IServiceScopeFactory instead; inside ExecuteAsync , for each unit of work, do `using var scope = factory.CreateScope(); var db = scope.ServiceProvider.GetRequiredService ();`. Each iteration then gets a fresh, correctly disposed context.

Question 15

How would you explain where you applied SOLID in your last project?

Accepted Answer

In short: Give a concrete STAR-style example. Our reporting module had exports to PDF and Excel inside one 2,000-line class. I introduced IReportExporter with one class per format and registered them in DI. The controller picks one by format key (OCP, SRP). Data access moved behind IReportRepository (DIP), which let us unit-test the exporters with fake data. Adding CSV later took half a day and touched no existing code.

SOLID Principles with Examples