{"id":926,"date":"2025-04-09T19:18:19","date_gmt":"2025-04-09T18:18:19","guid":{"rendered":"https:\/\/debuggersspace.com\/?p=926"},"modified":"2025-04-09T19:27:15","modified_gmt":"2025-04-09T18:27:15","slug":"understanding-dependency-injection-and-ioc-in-net-core-a-beginner-friendly-guide-with-real-world-examples","status":"publish","type":"post","link":"https:\/\/debuggersspace.com\/index.php\/2025\/04\/09\/understanding-dependency-injection-and-ioc-in-net-core-a-beginner-friendly-guide-with-real-world-examples\/","title":{"rendered":"Understanding Dependency Injection and IoC in .NET Core \u2013 A Beginner-Friendly Guide with Real-World Examples"},"content":{"rendered":"
\n
\n \t<\/i> Read Time:<\/span>4 Minute, 14 Second <\/div>\n\n <\/div>

\ud83d\udd0d Introduction<\/h2>\n

As a new developer, you\u2019ve probably come across a situation where one class creates and controls the behavior of another class, making it tightly coupled and hard to test or extend. This is where Dependency Injection (DI)<\/strong> and Inversion of Control (IoC)<\/strong> come to the rescue.<\/p>\n

In this blog, we\u2019ll break down these concepts in simple terms, walk through real-world examples, and implement them using .NET Core<\/strong>, including Entity Framework Core registration in the DI container. We’ll also tackle common follow-up interview questions at the end.<\/p>\n

\n

\ud83e\udde0 What is Dependency Injection (DI)?<\/h2>\n

Dependency Injection<\/strong> is a software design pattern that helps you achieve loose coupling<\/strong> between classes. Instead of a class creating its own dependencies, they are provided from the outside, typically via constructor parameters.<\/p>\n

\n

\ud83d\udd0c Think of DI as plugging in different components into a machine instead of soldering them permanently.<\/p>\n<\/blockquote>\n

\n

\ud83d\udd04 What is Inversion of Control (IoC)?<\/h2>\n

Inversion of Control<\/strong> is the broader concept behind Dependency Injection. It means handing over the control of object creation to a framework or container. In .NET Core, the built-in IoC container<\/strong> handles object creation, lifetime management, and injection for you.<\/p>\n

\n

\ud83e\udde0 IoC = \u201cDon\u2019t call me, I\u2019ll call you.\u201d<\/p>\n<\/blockquote>\n

\n

\u2699\ufe0f Types of Dependency Injection in .NET Core<\/h2>\n
    \n
  1. \n

    Constructor Injection<\/strong> \u2705 (Most common)<\/p>\n<\/li>\n

  2. \n

    Property Injection<\/strong><\/p>\n<\/li>\n

  3. \n

    Method Injection<\/strong><\/p>\n<\/li>\n<\/ol>\n

    We’ll focus on Constructor Injection<\/strong> here.<\/p>\n

    \n

    \ud83d\udce6 Real-Time Example: Notification System<\/h2>\n

    Scenario<\/h3>\n

    We need a system to send email notifications. We\u2019ll inject an EmailNotificationService<\/code> into a controller rather than creating it inside.<\/p>\n

    Step 1: Define the Interface<\/h3>\n
    \n
    public<\/span> interface<\/span> INotificationService<\/span>
    \n{
    \nvoid<\/span><\/span> Send<\/span>(string<\/span><\/span> to, string<\/span> message);
    \n}
    \n<\/code><\/div>\n<\/div>\n
    \n

    Step 2: Implement the Service<\/h3>\n
    \n
    public<\/span> class<\/span> EmailNotificationService<\/span> : INotificationService<\/span>
    \n{
    \npublic<\/span><\/span> void<\/span> Send<\/span>(string<\/span><\/span> to, string<\/span> message)
    \n{
    \nConsole.WriteLine($\"Email sent to {to}<\/span><\/span>: {message}<\/span>\");
    \n}
    \n}
    \n<\/code><\/div>\n<\/div>\n
    \n

    Step 3: Inject into Controller<\/h3>\n
    \n
    public<\/span> class<\/span> NotificationController<\/span> : ControllerBase<\/span>
    \n{
    \nprivate<\/span> readonly<\/span> INotificationService _notificationService;<\/code><\/code>public<\/span><\/span> NotificationController<\/span>(INotificationService notificationService<\/span>)
    \n{
    \n_notificationService = notificationService;
    \n}<\/code><\/code>[HttpPost<\/span>]\npublic<\/span><\/span> IActionResult NotifyUser<\/span>(string<\/span><\/span> email, string<\/span> message)
    \n{
    \n_notificationService.Send(email, message);
    \nreturn<\/span> Ok(“Notification sent!”<\/span>);
    \n}
    \n}<\/p>\n<\/div>\n<\/div>\n
    \n

    Step 4: Register in Program.cs<\/code><\/h3>\n
    \n
    \n

    var<\/span> builder = WebApplication.CreateBuilder(args);<\/code><\/p>\n

    builder.Services.AddScoped<INotificationService, EmailNotificationService>();
    \nvar<\/span> app = builder.Build();<\/p>\n<\/div>\n<\/div>\n

    \n

    \ud83d\uddc3\ufe0f How Do You Register EF Core in the DI Container?<\/h2>\n

    Entity Framework Core\u2019s DbContext<\/code> is also a dependency and must be registered in the DI container:<\/p>\n

    Sample ApplicationDbContext<\/code><\/h3>\n
    \n
    public<\/span> class<\/span> ApplicationDbContext<\/span> : DbContext<\/span>
    \n{
    \npublic<\/span><\/span> ApplicationDbContext<\/span>(DbContextOptions<ApplicationDbContext> options<\/span>)
    \n: base<\/span>(options<\/span>) { }<\/code><\/code>public<\/span> DbSet<User> Users { get<\/span>; set<\/span>; }
    \n}<\/div>\n<\/div>\n

    Registering EF Core in Program.cs<\/code><\/h3>\n
    \n
    builder.Services.AddDbContext<ApplicationDbContext>(options =>
    \noptions.UseSqlServer(builder.Configuration.GetConnectionString(\"DefaultConnection\"<\/span>)));
    \n<\/code><\/div>\n<\/div>\n
    \n

    \ud83e\uddea Unit Test Example with Moq<\/h2>\n
    \n
    public<\/span> class<\/span> NotificationControllerTests<\/span>
    \n{
    \n[Fact<\/span>]\npublic<\/span><\/span> void<\/span> NotifyUser_SendsEmail_ReturnsOk<\/span>()
    \n{
    \nvar<\/span> mockService = new<\/span> Mock<INotificationService>();
    \nvar<\/span> controller = new<\/span> NotificationController(mockService.Object);<\/code><\/code>var<\/span> result = controller.NotifyUser(“test@example.com”<\/span>, “Welcome!”<\/span>);<\/code><\/code>Assert.IsType<OkObjectResult>(result);
    \n}
    \n}<\/p>\n<\/div>\n<\/div>\n
    \n

    \ud83d\uddbc\ufe0f Visual Diagram \u2013 DI with IoC Container<\/h2>\n

    \"\"<\/p>\n

    \n

    \u2705 Benefits of Dependency Injection and IoC<\/h2>\n
    \n
    \n\n\n\n\n\n\n\n\n\n
    Feature<\/th>\nBenefit<\/th>\n<\/tr>\n<\/thead>\n
    \ud83e\udde9 Loose Coupling<\/td>\nComponents depend on abstractions, not concrete classes.<\/td>\n<\/tr>\n
    \ud83e\uddea Testability<\/td>\nEasier to write unit tests with mocks\/fakes.<\/td>\n<\/tr>\n
    \ud83d\udd01 Flexibility<\/td>\nSwap implementations without changing dependent classes.<\/td>\n<\/tr>\n
    \ud83e\uddfc Clean Code<\/td>\nKeeps classes focused and readable.<\/td>\n<\/tr>\n
    \ud83d\udd0d Debuggability<\/td>\nIsolated testing simplifies debugging.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n<\/div>\n
    \n

    \u2753 Interview Follow-Up Questions & Answers<\/h2>\n

    \ud83d\udd39 Normal Questions<\/strong><\/h3>\n

    Q1: What is the difference between IoC and DI?<\/strong>
    \ud83d\udc49 IoC is the principle of delegating control to a container. DI is one implementation of IoC, where dependencies are provided from the outside.<\/p>\n

    Q2: Why is constructor injection preferred?<\/strong>
    \ud83d\udc49 It makes dependencies mandatory and explicit. It\u2019s also easier for testing and ensures the object is always initialized properly.<\/p>\n

    Q3: What are the lifetimes of services in .NET Core?<\/strong><\/p>\n

      \n
    • \n

      Transient<\/code>: New instance every time.<\/p>\n<\/li>\n

    • \n

      Scoped<\/code>: One instance per request.<\/p>\n<\/li>\n

    • \n

      Singleton<\/code>: One instance for the app’s lifetime.<\/p>\n<\/li>\n<\/ul>\n

      Q4: How do you register multiple implementations of the same interface?<\/strong><\/p>\n

      \n
      builder.Services.AddTransient<INotificationService, EmailNotificationService>();
      \nbuilder.Services.AddTransient<INotificationService, SmsNotificationService>();
      \n<\/code><\/div>\n<\/div>\n

      You can inject IEnumerable<INotificationService><\/code> to resolve both.<\/p>\n

      Q5: What is the default IoC container in .NET Core?<\/strong>
      \ud83d\udc49 Microsoft.Extensions.DependencyInjection is the built-in default IoC container.<\/p>\n

      \n

      \ud83d\udd39 Tricky Questions<\/strong><\/h3>\n

      Q6: Can you inject a service inside another injected service?<\/strong>
      \ud83d\udc49 Yes. The DI container supports nested dependencies and will resolve the full dependency tree.<\/p>\n

      Q7: What happens if you inject a scoped service into a singleton?<\/strong>
      \ud83d\udc49 It causes a runtime exception. Scoped services cannot be safely injected into singletons. You should use IServiceProvider<\/code> or a factory pattern instead.<\/p>\n

      Q8: How would you resolve dependencies dynamically at runtime?<\/strong>
      \ud83d\udc49 You can use IServiceProvider.GetService<T>()<\/code> or ActivatorUtilities<\/code>.<\/p>\n

      Q9: How can you replace a service at runtime (e.g., in integration tests)?<\/strong>
      \ud83d\udc49 Use the ConfigureTestServices()<\/code> method in WebApplicationFactory<\/code> or use Replace()<\/code> extension from Microsoft.Extensions.DependencyInjection.Abstractions<\/code>.<\/p>\n

      Q10: What if a dependency has its own dependencies?<\/strong>
      \ud83d\udc49 The IoC container recursively resolves all nested dependencies automatically.<\/p>\n

      \n

      \ud83c\udfaf Summary<\/h2>\n
        \n
      • \n

        Dependency Injection<\/strong> enables decoupled and testable designs.<\/p>\n<\/li>\n

      • \n

        IoC<\/strong> delegates object creation to a container.<\/p>\n<\/li>\n

      • \n

        .NET Core<\/strong> makes it easy with a built-in DI system.<\/p>\n<\/li>\n

      • \n

        EF Core<\/strong> registration and service lifetimes are crucial for robust application architecture.<\/p>\n<\/li>\n<\/ul>\n

        \n

        \ud83d\udce2 Final Thoughts<\/h2>\n

        Mastering Dependency Injection and IoC is essential for modern .NET developers. It\u2019s not just about patterns \u2014 it\u2019s about building clean, flexible, testable, and maintainable systems.<\/p>\n","protected":false},"excerpt":{"rendered":"

        \ud83d\udd0d Introduction As a new developer, you\u2019ve probably come across a situation where one class creates and controls the behavior of another class, making it tightly coupled and hard to test or extend. This is where Dependency Injection (DI) and Inversion of Control (IoC) come to the rescue. In this blog, we\u2019ll break down these […]<\/p>\n","protected":false},"author":43,"featured_media":927,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_uag_custom_page_level_css":"","footnotes":""},"categories":[15,159],"tags":[218,152,219],"class_list":["post-926","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-net-core-3-1","category-net-core-top-50-qa","tag-dependency-injection","tag-designpattern","tag-ioc"],"uagb_featured_image_src":{"full":["https:\/\/debuggersspace.com\/wp-content\/uploads\/2025\/04\/ChatGPT-Image-Apr-9-2025-09_05_09-PM-e1744222811442.png",1024,517,false],"thumbnail":["https:\/\/debuggersspace.com\/wp-content\/uploads\/2025\/04\/ChatGPT-Image-Apr-9-2025-09_05_09-PM-e1744222811442-150x150.png",150,150,true],"medium":["https:\/\/debuggersspace.com\/wp-content\/uploads\/2025\/04\/ChatGPT-Image-Apr-9-2025-09_05_09-PM-e1744222811442-300x151.png",300,151,true],"medium_large":["https:\/\/debuggersspace.com\/wp-content\/uploads\/2025\/04\/ChatGPT-Image-Apr-9-2025-09_05_09-PM-e1744222811442-768x388.png",750,379,true],"large":["https:\/\/debuggersspace.com\/wp-content\/uploads\/2025\/04\/ChatGPT-Image-Apr-9-2025-09_05_09-PM-683x1024.png",683,1024,true],"1536x1536":["https:\/\/debuggersspace.com\/wp-content\/uploads\/2025\/04\/ChatGPT-Image-Apr-9-2025-09_05_09-PM-e1744222811442.png",1024,517,false],"2048x2048":["https:\/\/debuggersspace.com\/wp-content\/uploads\/2025\/04\/ChatGPT-Image-Apr-9-2025-09_05_09-PM-e1744222811442.png",1024,517,false]},"uagb_author_info":{"display_name":"Himanshu Namdeo","author_link":"https:\/\/debuggersspace.com\/author\/admin\/"},"uagb_comment_info":1,"uagb_excerpt":"\ud83d\udd0d Introduction As a new developer, you\u2019ve probably come across a situation where one class creates and controls the behavior of another class, making it tightly coupled and hard to test or extend. This is where Dependency Injection (DI) and Inversion of Control (IoC) come to the rescue. In this blog, we\u2019ll break down these…","_links":{"self":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/posts\/926"}],"collection":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/users\/43"}],"replies":[{"embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/comments?post=926"}],"version-history":[{"count":4,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/posts\/926\/revisions"}],"predecessor-version":[{"id":932,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/posts\/926\/revisions\/932"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/media\/927"}],"wp:attachment":[{"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/media?parent=926"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/categories?post=926"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/debuggersspace.com\/index.php\/wp-json\/wp\/v2\/tags?post=926"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}