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.
C#
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.