FAQ Design Patterns

Question 1

Abstraction Encapsulation

Answer 1

Abstraction

refers to modelling of complex entity through abstracts taking only relevant details and skipping irrelevant details.

It hides implementation details. It helps in reducing code complexity and standardization.

Achieved using Abstract classes and Interfaces

For example creating interface of product service and only declaring what it can do. How is later implemented by relegated classes

Encapsulation

Refers to wrapping data and behavior of entity and giving public access points to these.

Achieved using class access Modifiers getters setters

It helps in data integrity and modularity. Avoids accidental overwrites of data through validations in setters.

For example creating Patient class to protect PHI data

Question 2

Inheritance

Answer 2

Extending existing types to create specialised types giving hierarchy.

It helps in reusability

For example creating admin from user. Admin is a type of user

Question 3

Polymorphism

Answer 3

Refers to ability of entity to take different forms based on context.

Achieved using overloading and overriding

Helps in generic coding flexibility

For example a search function being able to function differently based on filter types

Question 4

Over loading vs Over ridding

Question 5

Shadowing
Method Hiding

Answer 5

Child methods will be hidden from parents during polymorphism

Child methods will not be invoked by parent class during polymorphism

Only happens when parent is pointing towards child instance

It is implementation using new keyword on same signature method of parent in child class

Useful in liskov problem when child doesn’t implement everything parent does.

Question 6

Operator overloading

Question 7

What is abstract classes

Answer 7

Partially defined parent class. Some implementations defined and some which is left for child to implement

It can be a base class but can’t have instances. Runtime safety.

Create child, implement abstract to create instances

Abstract class. Abstract method

Question 8

Why do we need shadowing

Answer 8

Hiding is a hack to achieve safe polymorphism by following LSP when a child class doesn’t implement all methods of base class and needs to be hidden so that base pointing to child can’t invoke it and use the base method.

Shadowing is a reactive measure/hack when face a liskov problem due to child not implementing all methods of parent which gives unexpected behaviour runtime errors

Hack when child class doesn’t implement all methods of parent
Liskov problem and happens due to wrong abstraction . It causes unexpected or runtime errors

Question 9

Shadowing Hiding vs Overriding

Answer 9

Overriding is type of polymorphism. Parent class can invoke child methods which are overriden when parent points to a child instance.

In shadowing, parent class can’t invoke child method because it is hidden from the parent. Only instance child class can invoke those methods

Question 10

Nested class use cases

Answer 10

Class definition inside another class

Deeper logical group classes than Namespaces

When nested class is only useful to enclosing class.

For example prescription validation is only rental order

Question 11

Can nested class access outer class variables

Answer 11

No. Only structural connection. No instance connection.

We need to pass an instance and then access

Question 12

Can nested have any access Modifiers in nested class

Answer 12

Technically yes.

If the usage to is to only logical group : public

If only used for related and hidden : private

Question 13

Partial classes

Answer 13

Can be written in two different physical files but compiler will compile into one class

We need to use partial class

Useful when we need to organise complex code into different files.

DO NOT TELL PARALLEL DEVELOPMENT BY MULTIPLE

Question 14

Abstract method is virtual method ?

Answer 14

Yes. Child can override. It is implicitly virtual

Question 15

Is it compulsory to implement abstract methods

Answer 15

Yes. If not, compile error

Question 16

Why can’t simple base class replace abstract class

Answer 16

We can’t leave some without implementation. We have to write dummy implementation which is tech debt. Not clean code

Question 17

What are interfaces

Answer 17

Interface is a contract
With the consumers of the interface.

Interface supports multiple inheritance which Helps in versioning by implementing multiple interfaces.

Helps in creating loosely coupled applications

Consumer MUST implement all properties and methods defined by interface. Else compile error

Contract between developer who is writing contract so he can use the concrete classes safely because another created the concrete strictly following contract rules. Else compile error and impact is shown

Contract creator will use interface reference = to concrete class and invoke the methods of interface

Question 18

Private methods ?
Logic

Answer 18

Only pure signature

No access Modifiers. Private gives Compile error

Now default implementation can be given

Question 19

Interface vs Abstract class

Answer 19

Interface only signatures but abstract can some definition some signature

Interface to plan abstraction. After defining Interface we can create abstract class if there are related classes implementing it and have same logic.
Abstract class to implement abstraction. Common logic of related classes go in abstract class where the class itself shouldn’t exist as an entity in code.

Interface supports multiple inheritance but abstract only supports single inheritance.

Question 20

Constructor and order

Answer 20

Special methods which are automatically invoked when instance created. Used to initialize variables

Parent then child constructor order

Question 21

What is the goal of SOLID principles

Answer 21

Minimize dependencies

Write reliable code

Code easy to understand maintain test and refactor

Question 22

Initializer order

Answer 22

First child then parent

Question 23

Static constructor order

Answer 23

Child then parent

Then
Instance constructor of child then instance constructor of parent

Question 24

When static constructor fires

Answer 24

First time the class is accessed

Question 25

Single Responsibility Principle

Answer 25

A class should have only one purpose and be focused on it. Modular code. Lean and focused class. Quality of class. Easy to understand and maintain For example a service class should only focus on business logic. Not notifications and data access

Question 26

Open closed principle

Answer 26

Class is open for extension and closed for modification If impact of class change is high then stable consumers needs to be tested again. Keeps existing unaffected and only new features need to be tested. Instead of adding another else if, create new interface and implement its concrete. Pick using behavior pattern like strategy.

Question 27

Liskov Substitution Principle

Answer 27

Child class should be substitute the parent class without changing existing behaviour. Without side effects and seamlessly Ensures safe polymorphism else we get runtime exceptions or unexpected behaviour For example a sampleorderprocessor which inherits orderprocessor that has billing method can't be substituted because sample orders are not to be billed Split interface and Compose. Then create concrete classes

Question 28

How to solve liskov problem

Answer 28

Understand requirement Refactor. Interface and Compose. Then create concrete class. Hack Method hiding

Question 29

Interface Segregation Principle

Answer 29

No class should be forced to implement methods that it does not need. Else we will have dummy implementations and that is technical debt Instead of creating huge interfaces. Split it and compose. For example. Instead of useractions. Have patientactions. Admin actions

Question 30

Liskov vs Interfaces Segregation

Answer 30

Liskov happens when inheritance is done wrong and causes unsafe polymorphism Interface focuses on class implementing Interface

Question 31

Dependency Inversion

Answer 31

Higher level modules should not directly depend on low level modules and instead via abstractions Helps us not be tied to specific implementation. Else refactoring will be a major rewrite because the related code is scattered. Here it centralise and only one place needs to be changed. For example endpoint shouldn't directly depend on service instead have an abstraction of service so that implementation of service change doesn't impact the controller. Because the new service will implement the contract

Question 32

How to application decoupling

Answer 32

New keyword is scattered and tied to specific concrete implementation Dependency Inversion and dependency Injection gives decoupling We first make high level class depend only on abstractions of concrete implementation And then a provider creates the concrete object and injects for the class

Question 33

Inversion of control

Answer 33

We invert the unnecessary additional work of a class to outside provider so that class can focus on it's single Responsibility Loosely couple object creation and usage.

Question 34

Dependency Injection

Answer 34

Technique to Implementation of INVERSION OF CONTROL principle. Class delegates object creation to external provider. The provider creates the instance and injects it. Class only focuses on its single Responsibility

Question 35

What is composition

Answer 35

Composition is whole object which is parent Is owner of the part object. That object isn't shared and parent controls the lifetime which is it's own lifetime ————— Part whole relationship Where lifetime of part object and whole object is same One can't exist without other Like patient is whole object. Disease is part object. Patient is only patient when they have disease. Tight connections

Question 36

What is aggregation

Answer 36

There is relationship between part object and whole object but they are independent of each other. They can exist without the other. Like patient has a doctor object. Doctor object can patient object. They own their own lifetimes

Question 37

What is association

Answer 37

Defines that two objects depend on each other Composition and aggregation are subset of association that have part whole relationship Like patient class can have part object to get appointment dates

Question 38

What are design patterns

Answer 38

Well tested solutions for Recurring architectural problems Example. Repository Pattern. Factory Pattern CQRS

Question 39

Prototype Pattern

Answer 39

Fully initialize instance to be copied or cloned

Question 40

Adapter Pattern

Answer 40

Helps incompatible interfaces compatible

Question 41

Repository Pattern

Answer 41

Abstract and centralise Data access logic layer Layer of separation between business logic and data access layer Makes code modular maintainable and testable

Question 42

Categories of design patterns

Answer 42

Gang of four. Creational - problems related object creation Singleton for shared single instance Factory Pattern for complex object creation in centralised manner Behavioural to deal with problems of communication between objects Chain of responsibilities like middlewares Mediator pattern simplifies communication between classes. Structural to solve concerns of class Structure and object composition Adapter to match interfaces of different classes

Question 43

Singleton Pattern

Answer 43

Pattern to create single shared instance of app lifetime and providing a global access point to it Useful for caching and logging

Question 44

Structure of Singleton

Answer 44

There should be a root. Whole part relationship. Instance of the class as private field with static so that only one exists A static readonly lock for thread safely Concurrent Collections for state for thread safety Lazy loading

Question 45

Why private constructor

Answer 45

So that outside code can't create instance because idea is to have only one instance

Question 46

Static class with everything static and no constructor vs private constructor

Answer 46

Static is a keyword Singleton is a design pattern Static class can't have instances Singleton uses Static features with More features like thread safety, lazy loading, performance. Has a defined structure. Static doesn't have state thread safety. Can't have instances. Can't implement interface. Can't have inheritance. Can't be injected.

Question 47

How to implement thread safety in Singleton pattern

Answer 47

Lock keyword helps implement thread safety. The code block will get executed by only on thread at a given time. Other threads wait and there is no conflicts If not there then unexpected behaviour Use lock. Make the lock static and readonly Only one thread can enter the block of code. Other threads will be waiting Multithreaded environment like c#. Multiple threads can execute code.

Question 48

Why is there double null check in Singleton

Answer 48

Inner check is for lazy loading. Only if some state is null, only then initialize. Like get method. Only initialize when it is first called and check if it is null. Don't at constructor. Outer check is for performance. Make sure that lock is not obtained unnecessarily. Unless instance not created or state not initialized In single check all thread obtain lock even if instance already created

Question 49

How to get rid of double check lock

Answer 49

Use lazy keyword Thread safety guaranteed Late initialization When accessing .Value ... the value gets initialized

Question 50

Which design pattern have you used in your projects

Answer 50

Repository Pattern. Unit of work. Options Pattern. Factory Pattern

Question 51

What is Repository Pattern

Answer 51

Abstract and centralise data access layer Helps us to have consistent interface for CRUD actions of model Loosely coupled architecture Reusable code by using abstract repository

Question 52

Is data access layer and repository same

Answer 52

No Data access layer is more detailed steps on to access data from source Repository is abstraction over DAL. It is high level. It gives what CRUD actions an happen on model and just that, no implementation of getting data.

Question 53

What is generic repository Pattern

Answer 53

It is extension to repository Pattern. It helps use to create a generic repository interface for all entities instead of creating a repository each for every entity

Question 54

Is abstraction the only benefit of repository

Answer 54

Repository helps in loose coupling but also reusability of code across DALs Common logic in DALs can be put in a common abstract class and all repositories can inherit

Question 55

How to implement transactions in repository

Answer 55

Unit of work design pattern

Question 56

What is unit of work pattern

Answer 56

Helps abstract transactions in repository

Question 57

What is a transaction

Answer 57

Group of tasks or operations Either whole group is committed if all tasks are completed successfully If there is an issue with even one task. The whole group is rolled back

Question 58

Do we need repository when entity framework does the same job

Answer 58

Even though it is repository with unit of work, it is a good practice to implement an abstraction over it for long term adaptability. It can be an abstraction for any kind of data source. If we decide to replace, then we have a centralised place to do so It is easier to implement mock unit testing Always good to have abstraction whenever we use third party library in case we need to replace It can be overkill if different types of data source or replacement of entity framework is not expected Entity Framework is a technology to handle repository over only heterogeneous relational database only. Repository Pattern can handle repository over any heterogeneous data sources.

Question 59

What is mock testing

Answer 59

Repository represented by generic repository interface helps in easy unit testing. It can be isolated for mock unit testing 1. Helps in bypassing the data access logic to test only the business logic 2. Helps in parallel development and testing. When another has not completed code. We can still test our part of code by mocking the code that is not complete. Helps save time.

Question 60

How repository Pattern helps in unit testing

Answer 60

Repository pattern abstracts the data access layer, letting business logic depend on interfaces instead of EF or SQL. This makes unit testing easy because we can mock repositories and return fake data without hitting the database. It isolates business logic, supports mocking frameworks like Moq, speeds up test runs, and improves maintainability in large systems.

Question 61

What is factory Pattern

Answer 61

Creational pattern Centralises object creation Making application loosely coupled

Question 62

How does centralised object creation help in loose coupling

Answer 62

When new keyword is used to create object, we are using a reference which makes consumer tightly coupled to the specific implementation Every consumer would have to create the same and hence new keyword is scattered throughout the code Switching an implementation would be a major rewrite and many code file changes So better to have it created at one place. Change in one place.

Question 63

What is IoC

Answer 63

Design principle states that class should delegate additional work than core work to external framework so that class can focus on it's single Responsibility

Question 64

What is dependency Injection pattern

Answer 64

Is a technique To implement Inversion of control principle It will create the object and provide the consumer It centralised dependencies of application. Decoupling consumers and dependencies. Easy to test and refactor happens only on few files Loosely couple usage and creation

Question 65

What is service locator

Answer 65

Centralised registry That retrieve and manage dependencies. Searches for it. It hides dependencies of a class and doesn't follow explicit dependency rules Class still depends on the service locator

Question 66

Service locator vs dependency Injection

Answer 66

Service locator is tightly coupled application. Dependency loosely coupled. It doesn't follow explicit Dependency rules. Consumer doesn't explicitly state dependencies but has an indirect path to search for it making dependencies hidden. Class needs to know where the Dependency is coming from Dependency Injection resolves the dependencies on its own scope and injects. Class doesn't need to know where the Dependency is coming from

Question 67

Can we have simple class in dependency Injection

Answer 67

Yes. But that tightly couples consumer to an implementation Abstraction gives loose coupling

Question 68

Is dependency Injection a design pattern

Answer 68

No. It is a technique to implement Inversion of control principle It doesn't have its own pseudo code.

Question 69

Is dependency Injection factory Pattern

Answer 69

No. Dependency Injection only focuses on Injection of Dependency We have to say how to construct the object. Factory Pattern is a way to do that for complex objects in a centralised way

Question 70

Static DI vs Dynamic DI

Answer 70

Static DI needs a restart of application for any change Dynamic DI will create the object at runtime if it needs a change. Static is done using type implementation style Dynamic is done using factory implementation style Static use for service, repository, logger Dynamic use for creating order processors based on user selection

Question 71

What is real factory pattern

Answer 71

It defines interface for object creation and class decide which concrete implementation for the object WITH factory method allows class to delegate the instance creation to subclass

Question 72

When to use factory pattern

Answer 72

If the object creation pattern is complex If certain combinations of dependency gives new object behaviours Like different types of order processor is created based on product selected, whether the patient is at facility or homecare, whether they billing is to be free, insurance paid or customer paid.

Question 73

Example of factory pattern

Answer 73

different types of order processor is created based on product selected, whether the patient is at facility or homecare, whether they billing is to be free, insurance paid or customer paid. We create a interface for orderprocessor with a factory method to create the object. And methods to vary the behaviour based on product, location and payor Default class implements it with virtual for all those variations Subclass of Default class will override the specialised variation. And its object is returned by the factory method

Question 74

Factory method vs Factory Pattern

Answer 74

Pattern is the bigger picture Factory method is lower level. It wires up the object creation

Question 75

How are new behaviours created in factory patternl

Answer 75

By inheritance. Inherit default class and override

Question 76

Abstract factory Pattern

Answer 76

Provides interface to create family of related objects without specifying concrete classes Abstraction to create related objects without specifying concrete classes

Question 77

Does abstract pattern use factory pattern inside

Answer 77

Yes. Abstract pattern aggregates similar families of factory Too many factories. Manage by grouping into abstract factory pattern

Question 78

Simple factory vs Real Factory method vs Abstract factory

Answer 78

Simple for Simple object creation Factory for complex object creation Abstract for when grouping factories Simple factory generates object using selection if else or lookup collection . Done using class Rest both need interface Factory pattern delegates object creation to subclasses Abstract pattern logically groups related factories ————— Simple factory is actually not factory pattern. Centralised object creation using polymorphism