- SOLID Design Principles in C#
SOLID principles are a set of five basic but powerful design principles in software development. They allow you to write manageable, scalable, and testable applications.
- Interface and Abstract Class
Interface defines a contract between itself and implementing classes. Abstract class enables developers to write partially implemented classes.
- Delegate with a real-life example
Delegate is a function or logic that is passed as a parameter to another function. The called function can invoke this logic at any time.
- Extension Method in C#
Extension Method allows you to add logic in existing classes without modifying them or creating a subclass. You can add functionality to a class that is not in your control, for example .Net classes.
- Pass parameters by value type and reference type
If you pass a parameter by value, any modification to that doesn’t affect the original one. This is not a case when passed as a reference.
- Value type and reference type
Value type is generally stored in the stack. Reference type is stored in the heap but it’s reference is stored in the stack.
- Access Modifiers in C#
Access modifiers (or access specifiers) are keywords in object-oriented languages that set the accessibility of classes, methods, and other members.
- Action, Func, and Predicate
Action, Func and Predicate are special types of delegate that are passed to a function as a parameter.
- Single Responsibility Principle
Single Responsibility Principle states that, a class should have responsibility for a single part of the program’s functionality. Which means, it should have only one reason to change.
- Open Closed Principle
It states that software entities should be open for extension, but closed for modification. Functionality should be added via extension (e.g. inheritance) instead of directly modifying class.