C# interview questions: What is Dependency Injection, and Why is it Useful in C#?

What is Dependency Injection, and Why is it Useful in C#?

Dependency Injection (DI) is a design pattern used to achieve Inversion of Control (IoC) between classes and their dependencies. In simple terms, Dependency Injection allows objects (often called dependencies) to be provided to a class rather than letting the class create them. This pattern promotes loose coupling and testability by making the components less dependent on each other’s instantiation.

What is Dependency Injection? (什么是依赖注入？)

In C#, Dependency Injection is a technique where an object’s dependencies are provided by an external entity (such as a framework or a container) rather than the object creating its dependencies. This concept works by injecting dependencies into the class from the outside, which helps manage objects’ lifecycles and promotes flexibility.

在 C# 中，依赖注入 是一种技术，其中对象的依赖项由 外部实体（如框架或容器）提供，而不是由对象自己创建。此概念通过从 外部 将依赖项注入类，从而有助于管理对象的生命周期，并提高灵活性。

Key Components of Dependency Injection (依赖注入的关键组件)

1. Service: The dependency or object that is being used (e.g., a logging or data access service).

   • 服务：被使用的依赖项或对象（例如，日志服务或数据访问服务）。

2. Client: The object that depends on the service to function.

   • 客户端：依赖于服务才能正常运行的对象。

3. Injector: The entity that injects the service into the client. In C#, this is often handled by a DI container like ASP.NET Core’s built-in DI container.

   • 注入器：将服务注入客户端的实体。在 C# 中，这通常由 依赖注入容器 处理，例如 ASP.NET Core 的内置 DI 容器。

Types of Dependency Injection (依赖注入的类型)

1. Constructor Injection (构造函数注入):
   Dependencies are provided through the class constructor.

   Example (示例):

   public class Car
   {
      private readonly IEngine _engine;
   
      public Car(IEngine engine)
      {
          _engine = engine;  // Inject the engine dependency via the constructor
      }
   
      public void Start()
      {
          _engine.Run();
      }
   }

2. Property Injection (属性注入):
   Dependencies are assigned through public properties.

   Example (示例):

   public class Car
   {
      public IEngine Engine { get; set; }  // Dependency is injected via property
   }

3. Method Injection (方法注入):
   Dependencies are passed as parameters to methods.

   Example (示例):

   public class Car
   {
      public void Start(IEngine engine)  // Dependency is injected via method parameter
      {
          engine.Run();
      }
   }

Why is Dependency Injection Useful in C#? (为什么依赖注入在 C# 中有用？)

1. Promotes Loose Coupling (促进松耦合):
   DI ensures that a class does not directly instantiate its dependencies. Instead, the dependencies are provided externally, making the class less dependent on specific implementations.

   DI 确保类不直接实例化其依赖项。相反，依赖项由外部提供，使类对特定实现的依赖性降低。

2. Improves Testability (提高可测试性):
   Because dependencies can be swapped for mocks or stubs during testing, DI improves the ease of writing unit tests, making it simpler to isolate the unit under test.

   由于可以在测试期间将依赖项替换为模拟或桩，DI 提高了编写单元测试的简便性，使得更容易隔离被测试的单元。

3. Simplifies Maintenance and Extensibility (简化维护和扩展性):
   DI makes it easier to change dependencies in the future. If a different implementation is needed, it can be injected without modifying the dependent class itself.

   DI 使得未来更容易更改依赖项。如果需要不同的实现，可以注入该实现，而无需修改依赖类本身。

4. Encourages Reusability (鼓励重用性):
   By decoupling components, DI encourages building reusable components, as dependencies can be injected in different contexts.

   通过解耦组件，DI 鼓励构建可重用组件，因为依赖项可以在不同的上下文中注入。

Example of Dependency Injection in ASP.NET Core (ASP.NET Core 中依赖注入的示例)

In ASP.NET Core, Dependency Injection is built-in, and services can be registered in the Startup.cs file using the ConfigureServices method. The framework will automatically inject services where needed.

在 ASP.NET Core 中，依赖注入 是内置的，服务可以在 Startup.cs 文件中通过 ConfigureServices 方法注册。框架将自动在需要的地方注入服务。

Example (示例):

public void ConfigureServices(IServiceCollection services)
{
    services.AddTransient<IEngine, Engine>();  // Register service
    services.AddScoped<ICar, Car>();
}

public class Car : ICar
{
    private readonly IEngine _engine;

    public Car(IEngine engine)  // Constructor injection
    {
        _engine = engine;
    }

    public void Drive()
    {
        _engine.Run();
    }
}

In this example:

• AddTransient: Registers the dependency (IEngine) to be created each time it is requested.
• Constructor Injection is used to inject the IEngine into the Car class.

Key Differences Between Dependency Injection and Traditional Object Creation (依赖注入与传统对象创建的关键区别)

Interview Questions (中英对照)

Q1. What is Dependency Injection, and why is it useful?

Dependency Injection is a design pattern where the dependencies of a class are provided by an external source rather than being created by the class itself. It promotes loose coupling, improves testability, and simplifies maintenance.

Q1. 什么是依赖注入？它为什么有用？

依赖注入是一种设计模式，类的依赖项由外部提供，而不是由类本身创建。它促进松耦合，提高可测试性，并简化维护。

Q2. What are the three types of Dependency Injection in C#?

The three types of DI are Constructor Injection, Property Injection, and Method Injection.

Q2. C# 中依赖注入的三种类型是什么？

三种依赖注入类型是 构造函数注入、属性注入 和 方法注入。

Q3. How does Dependency Injection improve unit testing?

DI makes unit testing easier by allowing dependencies to be replaced with mocks or stubs, isolating the unit under test and preventing external dependencies from affecting test results.

Q3. 依赖注入如何改进单元测试？

DI 通过允许用模拟或桩替换依赖项，使单元测试更加简便，从而隔离被测试的单元，防止外部依赖项影响测试结果。

Conclusion (结论)

Dependency Injection is a powerful design pattern in C# that encourages loose coupling, improves testability, and simplifies code maintenance by separating the creation and management of dependencies from the client class.
依赖注入是 C# 中强大的设计模式，通过将依赖项的创建和管理与客户端类分离，促进了松耦合、提高了可测试性，并简化了代码维护。

In modern frameworks like ASP.NET Core, DI is a built-in feature that enhances application architecture and scalability.
在像 ASP.NET Core 这样的现代框架中，DI 是内置功能，增强了应用程序架构和可扩展性。

Advanced Dependency Injection (DI) Patterns and Scopes in ASP.NET Core

In ASP.NET Core, Dependency Injection (DI) is a key part of the framework’s design. It allows for inversion of control (IoC), making it easier to decouple services and clients, improving testability, maintainability, and scalability. Understanding advanced DI patterns and DI scopes is essential for building efficient and scalable applications.

Advanced Dependency Injection Patterns (高级依赖注入模式)

In more complex applications, you may need advanced DI patterns to manage dependencies effectively. Here are some of the common advanced patterns:

1. Factory Pattern for Dependency Injection (工厂模式用于依赖注入)

In some scenarios, it’s necessary to create dependencies dynamically, based on runtime logic. The Factory Pattern allows you to inject a factory that generates instances of a service as needed.

在某些场景中，需要基于运行时逻辑动态创建依赖项。工厂模式 允许你注入一个工厂来根据需要生成服务的实例。

Example (示例):

public class CarFactory : ICarFactory
{
    public ICar CreateCar(string model)
    {
        if (model == "Sedan")
            return new Sedan();
        if (model == "SUV")
            return new SUV();
        throw new ArgumentException("Invalid model");
    }
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton<ICarFactory, CarFactory>();  // Register factory
}

Use Case (使用场景):

• When you need multiple implementations of a dependency and must decide at runtime which one to create.
• 当你需要依赖项的 多个实现 并且必须在运行时决定创建哪一个时。

2. Decorator Pattern with DI (使用依赖注入的装饰器模式)

The Decorator Pattern is used to extend the behavior of an object dynamically without altering its structure. In DI, it allows you to wrap services with additional functionality.

装饰器模式 用于在不更改对象结构的情况下动态扩展对象的行为。在依赖注入中，它允许你使用额外的功能 包装服务。

Example (示例):

public class LoggingCar : ICar
{
    private readonly ICar _innerCar;
    public LoggingCar(ICar car)
    {
        _innerCar = car;
    }

    public void Drive()
    {
        Console.WriteLine("Logging: Car is starting");
        _innerCar.Drive();  // Forward the call
    }
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddScoped<ICar, Car>();          // Base implementation
    services.Decorate<ICar, LoggingCar>();    // Apply decorator
}

Use Case (使用场景):

• When you need to add functionality to an existing service, such as logging, caching, or security checks.
• 当你需要为现有服务 添加功能，如 日志记录、缓存 或 安全检查 时。

3. Scoped Factories (有作用域的工厂)

Sometimes you need services that require scoped lifetimes but need to be created dynamically. By using scoped factories, you can inject a factory that creates scoped services within a controlled lifecycle.

有时你需要 有作用域的生命周期 服务，但需要动态创建。通过使用 有作用域的工厂，你可以注入一个工厂来在受控生命周期内创建作用域服务。

Example (示例):

public class ScopedServiceFactory
{
    private readonly IServiceProvider _provider;

    public ScopedServiceFactory(IServiceProvider provider)
    {
        _provider = provider;
    }

    public IScopedService CreateScopedService()
    {
        return _provider.GetRequiredService<IScopedService>();
    }
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddScoped<IScopedService, ScopedService>();
    services.AddTransient<ScopedServiceFactory>();
}

Use Case (使用场景):

• When you need scoped services but want to create them dynamically during the runtime of the application.
• 当你需要 有作用域的服务，但希望在应用程序运行时动态创建它们时。

4. Options Pattern with DI (带依赖注入的选项模式)

The Options Pattern is commonly used to configure services using settings from configuration files (like appsettings.json). It allows services to receive strongly typed configuration data via DI.

选项模式 通常用于通过配置文件（如 appsettings.json）配置服务。它允许服务通过 DI 接收强类型的配置数据。

Example (示例):

public class CarSettings
{
    public string Model { get; set; }
    public string Color { get; set; }
}

public class Car : ICar
{
    private readonly CarSettings _settings;

    public Car(IOptions<CarSettings> settings)
    {
        _settings = settings.Value;
    }

    public void Drive()
    {
        Console.WriteLine($"Driving a {_settings.Color} {_settings.Model}");
    }
}

public void ConfigureServices(IServiceCollection services)
{
    services.Configure<CarSettings>(Configuration.GetSection("CarSettings"));
    services.AddScoped<ICar, Car>();
}

Use Case (使用场景):

• When you need to inject configuration settings into a service for flexible, configurable services.
• 当你需要将 配置 设置注入到服务中以实现灵活的、可配置的服务时。

DI Scopes in ASP.NET Core (ASP.NET Core 中的 DI 作用域)

When registering services in ASP.NET Core, you can choose the lifetime scope for each service. The three main scopes are Transient, Scoped, and Singleton.

在 ASP.NET Core 中注册服务时，你可以为每个服务选择 生命周期范围。三种主要的作用域是 Transient、Scoped 和 Singleton。

1. Transient (瞬态):

• Created every time: A new instance of the service is created each time it is requested.

• 每次创建新实例：每次请求服务时，都会创建一个新实例。

• Use Case: Best for lightweight, stateless services that do not maintain internal state between calls.

• 使用场景：最适合轻量级的、无状态的服务，不在调用之间维护内部状态。

2. Scoped (有作用域的):

• Created once per request: A new instance of the service is created once per HTTP request (or scope).

• 每个请求创建一次：每个 HTTP 请求（或作用域）会创建一个新的服务实例。

• Use Case: Best for services that should maintain state within the scope of a single HTTP request (e.g., database contexts).

• 使用场景：最适合在单个 HTTP 请求范围内应保持状态的服务（例如数据库上下文）。

3. Singleton (单例):

• Created once: A single instance of the service is created the first time it is requested, and it is reused throughout the application’s lifetime.

• 只创建一次：第一次请求时创建服务的单个实例，并在应用程序的整个生命周期中重用。

• Use Case: Best for services that are expensive to create or need to be shared across all requests (e.g., logging services, configuration providers).

• 使用场景：最适合创建代价高昂或需要在所有请求之间共享的服务（例如日志服务、配置提供程序）。

Practical Example: Combining Scopes (实际示例：结合作用域)

Let’s consider a real-world example combining different DI scopes:

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddSingleton<ILogger, Logger>();         // Singleton logger
        services.AddScoped<IDatabaseContext, DbContext>(); // Scoped DB context
        services.AddTransient<IRepository, Repository>();  // Transient repository
    }
}

• Singleton Logger: This ensures that logging is consistent across all HTTP requests.
• Scoped Database Context: Each HTTP request gets its own instance of the database context to manage transactions.
• Transient Repository: The repository is stateless and can be created for each operation within the request.

Interview Questions (中英对照)

Q1. What are the different DI scopes in ASP.NET Core?

There are three DI scopes: Transient, Scoped, and Singleton. Transient services are created every time they are requested, Scoped services are created once per request, and Singleton services are created once and reused across the application’s lifetime.

Q1. ASP.NET Core 中有哪些不同的 DI 作用域？

ASP.NET Core 中有三种 DI 作用域：Transient、Scoped 和 Singleton。Transient 服务每次请求时都会创建，Scoped 服务每个请求创建一次，而 Singleton 服务在整个应用程序生命周期中只创建一次并重用。

Q2. Why would you use the Factory pattern with DI?

The Factory pattern is used with DI when you need to dynamically create services based on runtime logic. This is particularly useful when there are multiple implementations of a service, and the correct one must be selected at runtime.

**Q2. 为什么在依赖注入中使用工厂

…pattern when you need to dynamically create services based on runtime logic, particularly when multiple implementations of a service exist. The factory allows the appropriate service to be selected at runtime based on specific requirements.

Q2. 为什么在依赖注入中使用工厂模式？

在依赖注入中使用工厂模式，当你需要根据运行时逻辑动态创建服务时，尤其是当一个服务有多个实现时。工厂模式可以在运行时选择适当的服务。

Q3. What is the purpose of using Scoped services in ASP.NET Core?

Scoped services are used to ensure that a single instance of the service is created and maintained throughout the lifecycle of an individual HTTP request. This is especially useful for services that need to share data within the scope of a single request, such as a database context.

Q3. 在 ASP.NET Core 中使用有作用域的服务的目的是什么？

有作用域的服务确保在单个 HTTP 请求的生命周期内创建并保持服务的单个实例。它对需要在单个请求范围内共享数据的服务非常有用，例如数据库上下文。

Conclusion (结论)

Understanding advanced Dependency Injection patterns such as the Factory Pattern, Decorator Pattern, and different DI scopes in ASP.NET Core allows developers to build more flexible and maintainable applications. Proper use of Transient, Scoped, and Singleton lifetimes ensures that services are managed efficiently, improving performance and resource management.
理解 高级依赖注入模式（如工厂模式、装饰器模式）以及 ASP.NET Core 中的不同 DI 作用域 能帮助开发人员构建更灵活且易于维护的应用程序。合理使用 Transient、Scoped 和 Singleton 生命周期能确保高效管理服务，从而提升性能和资源管理。