OOP Concepts in C#

1. Encapsulation — private state with a controlled public API. BankAccount keeps _balance private and exposes Deposit() that rejects negative amounts.
2. Abstraction — expose what, hide how. IPaymentGateway.ChargeAsync() hides HTTP calls, signatures and retries.
3. Inheritance — a derived class reuses and extends a base. Contractor : Employee reuses Name and Describe().
4. Polymorphism — the same call behaves differently by type. employee.MonthlyPay() runs the Permanent or Contractor override at runtime.

In short: A class is a type definition (blueprint) describing fields, properties and methods; it exists in code and metadata.

• An object is an instance of that class created at runtime with new, occupying memory with its own state.
• One class, many objects.

In short: An abstract class can hold state, constructors and shared implementation, and a class can inherit only one.

• An interface is a contract; a class can implement many, and it has no instance state (default methods are allowed since C# 8).
• Use an interface for capabilities and dependency injection (IEmailSender) and an abstract class when related types share code and state (Shape, Employee).
• A common design is to use both: the interface for consumers, an abstract base for shared code.

In short: Not for classes — a class has exactly one base class, which avoids the diamond problem (ambiguity when two parents implement the same member).

• A class can implement multiple interfaces.
• If two interfaces declare the same member, use explicit interface implementation to disambiguate.

In short: public, private, protected, internal, protected internal, private protected (plus file for types).

• Defaults: class members are private; top-level types are internal; interface members are public.

In short: With override, the runtime type decides which method runs — true polymorphism.

• With hiding (new), the compile-time variable type decides: A x = new B(); x.Name() calls A.Name().
• Hiding breaks polymorphism and is usually a design smell.
• The compiler warns if you hide a member without the new keyword.

In short: Inheritance is a static "is-a" relationship fixed at compile time; subclasses depend on base-class internals, so base changes can break them.

• Composition is "has-a": an object holds other objects (often via interfaces) and delegates to them.
• You can swap them at runtime, test them in isolation and avoid class explosions.
• Use inheritance only when the subtype really is a substitutable kind of the base (see LSP).

In short: All three are "uses/has" relationships of different strength.

• Association: two classes know about each other and have independent lifetimes (Doctor–Patient).
• Aggregation: whole–part where the part can exist alone (Team–Player; delete the team and the players remain).
• Composition: whole–part with shared lifetime (Order–OrderLine, House–Room; delete the order and its lines go too).

In short: You can't instantiate it with new.

• It can have constructors, usually protected, which derived classes call via : base(...) to initialise shared state.
• An abstract class can also have no abstract members at all; it's then just a base that must not be used directly.

In short: Making Penguin : Bird and throwing NotSupportedException from Fly() violates Liskov substitution: callers that loop over birds and call Fly() will crash.

• Split the capability out: Bird (common: eat, lay eggs) plus an IFlyable interface implemented only by birds that fly.
• Code that needs flying asks for IFlyable.
• This is composition of capabilities over a deep hierarchy.

In short: Identify the responsibilities and extract each into a focused class behind an interface: IReportDataSource, IReportFormatter (with PdfFormatter and ExcelFormatter), IReportSender and ILogger.

• ReportGenerator then orchestrates them, receiving them by constructor injection.
• Add unit tests around the current behaviour before extracting (characterisation tests), then refactor in small steps.
• Result: SRP, OCP (new format = new formatter class) and easy mocking.