C# Object-oriented Programming Principles

Core Principles:
- Encapsulation: Bundling data and methods that operate on the data within a single unit (class). Protects data from outside interference.
- Inheritance: Mechanism to create a new class (derived class) from an existing class (base class). Promotes code reuse.
- Polymorphism: Ability to treat objects of different classes through a common interface. Achieved via method overriding and interfaces.
- Abstraction: Hiding complex implementation details and exposing only necessary features of the object.
Classes and Objects:
- Class: Blueprint for creating objects; defines properties (fields) and behaviors (methods).
- Object: Instance of a class; represents a specific implementation of the class.
Access Modifiers:
- public: Accessible from any other class.
- private: Accessible only within the defining class.
- protected: Accessible within the class and by derived classes.
- internal: Accessible within the same assembly.
Interfaces:
- Defines a contract that classes can implement.
- Can contain method signatures, properties, events, and indexers.
Abstract Classes:
- Cannot be instantiated directly; meant to be subclassed.
- Can contain both abstract methods (without implementation) and concrete methods.

Definition: Reusable solutions to common problems in software design. Provides best practices for coding and architecture.
Categories of Design Patterns:
- Creational Patterns: Deal with object creation mechanisms.
  - Singleton: Restricts instantiation of a class to one instance.
  - Factory Method: Defines an interface for creating an object, but lets subclasses alter the type of created objects.
  - Abstract Factory: Interface for creating families of related or dependent objects without specifying concrete classes.
- Structural Patterns: Deal with object composition.
  - Adapter: Allows incompatible interfaces to work together.
  - Composite: Composes objects into tree structures to represent part-whole hierarchies.
  - Decorator: Adds new functionality to an object dynamically.
- Behavioral Patterns: Deal with object interaction and responsibility.
  - Observer: Defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified.
  - Strategy: Defines a family of algorithms, encapsulates each one, and makes them interchangeable.
  - Command: Encapsulates a request as an object, thereby allowing for parameterization and queuing of requests.
Benefits of Using Design Patterns:
- Improved code readability and maintainability.
- Facilitation of communication among developers through established terminology.
- Promotion of best practices in software development.

Core Principles:
- Encapsulation: Combines data and methods in a class, protecting data from outside access.
- Inheritance: Enables creation of derived classes from base classes, facilitating code reuse.
- Polymorphism: Allows different classes to be treated as instances of the same class through interfaces and method overriding.
- Abstraction: Simplifies complex implementations by exposing only the necessary features to the user.
Classes and Objects:
- Class: Acts as a blueprint for objects, defining their properties (fields) and behaviors (methods).
- Object: A specific instance of a class, representing a unique implementation of the defined blueprint.
Access Modifiers:
- public: Accessible from any class.
- private: Restricted to the defining class only.
- protected: Accessible within the class and its derived classes.
- internal: Accessible within the same assembly.
Interfaces:
- Serve as contracts for classes, specifying methods, properties, events, and indexers to be implemented.
Abstract Classes:
- Cannot be instantiated directly; designed to be subclassed.
- May contain both abstract methods (without implementations) and concrete methods.

Definition: Established solutions for common issues in software design, providing best practices for coding and architecture.
Categories of Design Patterns:
- Creational Patterns: Focus on ways to create objects.
  - Singleton: Ensures a class has only one instance.
  - Factory Method: Interface for object creation, allowing subclasses to specify object types.
  - Abstract Factory: Interface for creating families of related objects without concrete class specification.
- Structural Patterns: Concerned with object composition.
  - Adapter: Bridges incompatible interfaces to work together.
  - Composite: Organizes objects into tree structures for part-whole relationships.
  - Decorator: Adds functionality to objects dynamically at runtime.
- Behavioral Patterns: Focus on relationships and responsibilities between objects.
  - Observer: Establishes a one-to-many dependency, notifying dependents of state changes.
  - Strategy: Encapsulates a family of algorithms, enabling interchangeable use.
  - Command: Encapsulates requests as objects for parameterization and queuing.
Benefits of Using Design Patterns:
- Enhances code readability and maintainability.
- Fosters clear communication among developers through common terminology.
- Encourages adherence to best practices in software development.