Software Development at CodingCrest

  • 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.
Coding Crest Back To The Top