Introduction One of the most important concepts in modern JavaScript and Angular development is the callback function . Callbacks are everywhere: Button clicks API calls Timers RxJS subscriptions Array methods Event listeners Many beginners struggle to understand the difference between: Normal functions Callback functions Event handlers Asynchronous functions In this complete guide, you’ll learn callback functions step by step — from beginner concepts to expert-level understanding with real Angular examples. 1. What is a Function? A function is a reusable block of code. function greet() { console.log("Hello"); } greet(); Output Hello Here: greet is a normal function It runs immediately when called 2. What is a Callback Function? A callback function is: A function passed as an argument to another function, which is executed later. This is one of the most important concepts in JavaScript. ...

SOLID principles are the foundation of clean architecture and design patterns in .NET Core applications. These principles help developers write scalable, maintainable, reusable, and testable code. 1. S — Single Responsibility Principle (SRP) Definition: A class should have only one reason to change. Alternative for: Large classes doing multiple jobs. Bad Example: public class UserService { public void RegisterUser() { } public void SendEmail() { } public void SaveToDatabase() { } } The class handles: User registration Email sending Database operations Good Example: public class UserService { public void RegisterUser() { } } public class EmailService { public void SendEmail() { } } public class UserRepository { public void Save() { } } Each class now has a single responsibility. 2. O — Open/Closed Principle (OCP) Definition: Software entities should be open for extension but closed for modification. ...

In .NET Core, design patterns are commonly used as alternatives to complex code structures like large if-else blocks, tight coupling, duplicated logic, and difficult-to-maintain code. Design Pattern Alternative For Purpose Factory Pattern Large if-else / switch statements Centralizes object creation logic Strategy Pattern Behavior-based if-else conditions Makes algorithms interchangeable State Pattern Complex state condition checks Encapsulates state-specific behavior Command Pattern Direct method calls Decouples request from execution Repository Pattern Scattered database queries Abstracts data access logic ...

Understanding yield in C# – Complete Guide with Examples In C#, yield is a special keyword used to create iterators . It helps return data one item at a time instead of returning the entire collection immediately. This feature is extremely useful for: Large data processing Memory optimization Lazy loading Streaming data File reading LINQ operations Infinite sequences In this article, we will explore: What yield is Why it is used How it works internally Syntax Real-world use cases Advantages and limitations Interview questions Best practices What is yield in C#? yield is a keyword that allows a method to return values one-by-one during iteration instead of returning all values at once. Normally, methods execute completely before returning data. But iterator methods using yield : Pause execution Return one value Resume from the same position later This process co...

Definition High-level modules should not depend on low-level modules. Both should depend on abstractions. 👉 Depend on interfaces/abstractions, not concrete classes. Purpose Reduce tight coupling Improve flexibility Enable dependency injection Make unit testing easier Build scalable architecture Bad Example ❌ Low-Level Class public class SqlRepository { public void Save() { Console.WriteLine("Saved to SQL"); } } High-Level Class public class InvoiceService { private readonly SqlRepository _repository = new SqlRepository(); public void CreateInvoice() { _repository.Save(); } } Problem InvoiceService directly depends on: SqlRepository If database changes: MongoDB PostgreSQL MySQL 👉 High-level code must change. This creates: Tight coupling Difficult testing Poor scalability Good Example ✅ Step 1: Abstraction public interface IReposi...

Definition Clients should not be forced to depend on interfaces they do not use. 👉 Prefer small focused interfaces instead of one large interface. Purpose Reduce unnecessary implementation Keep interfaces clean Improve flexibility Avoid unused methods Build modular systems Bad Example ❌ Large Interface public interface IWorker { void Work(); void Eat(); } Human Worker public class Human : IWorker { public void Work() { Console.WriteLine("Human Working"); } public void Eat() { Console.WriteLine("Human Eating"); } } Robot Worker public class Robot : IWorker { public void Work() { Console.WriteLine("Robot Working"); } public void Eat() { throw new Exception( "Robot doesn't eat" ); } } Problem Robot forced to implement: Eat() even though it doesn't need it. 👉 Violates IS...

Definition Objects of a derived class should be replaceable with objects of the base class without breaking application behavior. 👉 Child class should behave properly like parent class. Purpose Ensure proper inheritance Avoid incorrect subclass behavior Improve polymorphism Prevent runtime issues Build reliable OOP design Bad Example ❌ Parent Class public class Bird { public virtual void Fly() { Console.WriteLine("Bird Flying"); } } Child Class public class Ostrich : Bird { public override void Fly() { throw new Exception("Ostrich can't fly"); } } Problem Bird bird = new Ostrich(); bird.Fly(); ❌ Runtime failure. 👉 Child class breaks parent behavior. This violates LSP. Good Example ✅ Base Interface public interface IBird { void Eat(); } Flying Bird Interface public interface IFlyingBird { void Fly(); } Sparrow public class Sparrow : IB...

Definition Software entities should be: Open for extension Closed for modification 👉 You should be able to add new functionality without changing existing code. Purpose Prevent breaking existing code Improve scalability Reduce bugs during changes Make systems extensible Follow clean architecture principles Bad Example ❌ public class TaxCalculator { public decimal Calculate(string type, decimal amount) { if(type == "GST") { return amount * 0.18m; } else if(type == "NoTax") { return 0; } return 0; } } Problem Whenever new tax type comes: InternationalTax ServiceTax ExportTax 👉 Existing code must be modified repeatedly. This can: Introduce bugs Break old functionality Increase complexity Good Example ✅ Step 1: Abstraction public interface ITaxStrategy { decimal Calculate(decimal amou...

h2>Definition A class should have only one responsibility or one reason to change. 👉 One class = One job. Purpose Keep classes focused Reduce complexity Improve maintainability Make code easier to test Avoid tightly coupled logic Bad Example ❌ public class InvoiceService { public void CreateInvoice() { Console.WriteLine("Invoice Created"); } public void SaveToDatabase() { Console.WriteLine("Saved to DB"); } public void SendEmail() { Console.WriteLine("Email Sent"); } } Problem This class handles: Invoice creation Database operations Email sending 👉 Multiple responsibilities. Good Example ✅ Invoice Logic public class InvoiceService { public void CreateInvoice() { Console.WriteLine("Invoice Created"); } } Database Logic public class InvoiceRepository { public void Save() { Consol...

SOLID Principles in C# and .NET with Examples SOLID Principles in C# and .NET help developers build scalable, maintainable, and clean enterprise applications using object-oriented programming and ASP.NET Core. What are SOLID Principles? SOLID is a set of 5 object-oriented design principles used to build: Maintainable code Scalable applications Flexible architecture Clean and reusable systems Created by Robert C. Martin. Full Form of SOLID Letter Principle S Single Responsibility Principle O Open/Closed Principle L Liskov Substitution Principle I Interface Segregation Principle D Dependency Inversion Principle 1. Single Responsibility Principle (SRP) Definition A class should have only one reason to change. 👉 One c...

Interpreter Pattern in C# – Real-Time Example (Rule / Expression Evaluation) What is Interpreter Pattern? The Interpreter Pattern is a behavioral design pattern used to interpret and evaluate language grammar, expressions, or rules. 👉 Converts expressions into executable logic. It is commonly used in: Rule engines Formula calculators Query parsers Expression evaluators Why Use Interpreter Pattern? Evaluate expressions dynamically Build rule engines Parse custom languages Simplify grammar processing Encapsulate evaluation logic Real-Time Scenario Calculator System: 10 + 5 - 3 👉 Expression needs interpretation and execution. Real-Time Example – Simple Expression Interpreter Step 1: Expression Interface public interface IExpression { int Interpret(); } Step 2: Number Expression public class NumberExpression : IExpression { private readonly int _number; public NumberExpression(int...

What is Visitor Pattern? The Visitor Pattern is a behavioral design pattern that allows you to add new operations to existing object structures without modifying those classes. 👉 Separate: Object structure Operations/behaviors Why Use Visitor Pattern? Add new functionality easily Avoid modifying existing classes Follow Open/Closed Principle Separate business logic from objects Improve maintainability Real-Time Scenario Invoice System: Need multiple operations: PDF Export Excel Export Tax Calculation Report Generation 👉 Instead of modifying Invoice class repeatedly, use Visitors. Real-Time Example – Invoice Export System Step 1: Visitor Interface public interface IVisitor { void Visit(Invoice invoice); } Step 2: Element Interface public interface IElement { void Accept(IVisitor visitor); } Step 3: Concrete Element public class Invoice : IElement { public decimal A...

What is Memento Pattern? The Memento Pattern is a behavioral design pattern that allows you to save and restore an object's previous state without exposing its internal details. 👉 Used mainly for: Undo Rollback Checkpoints History tracking Why Use Memento Pattern? Save object snapshots Restore previous state Implement undo/redo Maintain encapsulation Track history safely Real-Time Scenario Text Editor: User types text Save state Undo changes 👉 Restore previous version easily. Real-Time Example – Text Editor Undo Feature Step 1: Memento Class public class EditorMemento { public string Content { get; } public EditorMemento(string content) { Content = content; } } Step 2: Originator Class public class TextEditor { public string Content { get; set; } // Save state public EditorMemento Save() { return new EditorMemento(Content); ...