Round #735

Write a basic dependency injection registration with services.AddScoped.

### Basic Dependency Injection Registration with `AddScoped` Here's an example of how to register a service with `AddScoped` in a .NET Core application: ```csharp using Microsoft.Extensions.DependencyInjection; // Define the interface for the service public interface IMyService { void DoSomething(); } // Implement the service public class MyService : IMyService { public void DoSomething() { Console.WriteLine("Doing something..."); } } // Register the service in the Startup.cs file public void ConfigureServices(IServiceCollection services) { services.AddScoped<IMyService, MyService>(); } ``` In this example: * We define an interface `IMyService` with a method `DoSomething`. * We implement the `IMyService` interface with a class `MyService`. * We register the `MyService` class as the implementation of `IMyService` using `AddScoped` in the `ConfigureServices` method. The `AddScoped` method registers the service as scoped, which means a new instance of the service will be created for each HTTP request. ### Using the Registered Service To use the registered service, you can inject it into a controller or another service: ```csharp [ApiController] [Route("api/[controller]")] public class MyController : ControllerBase { private readonly IMyService _myService; public MyController(IMyService myService) { _myService = myService; } [HttpGet] public IActionResult Get() { _myService.DoSomething(); return Ok(); } } ``` In this example, the `IMyService` instance is injected into the `MyController` constructor, and the `DoSomething` method is called when the `Get` action is invoked.

```csharp using Microsoft.Extensions.DependencyInjection; public class Startup { public void ConfigureServices(IServiceCollection services) { // Register a service with scoped lifetime services.AddScoped<ILogger, Logger>(); services.AddScoped<IUserService, UserService>(); } } public interface ILogger { void Log(string message); } public class Logger : ILogger { public void Log(string message) { Console.WriteLine($"Logged: {message}"); } } public interface IUserService { void GetUser(); } public class UserService : IUserService { private readonly ILogger _logger; public UserService(ILogger logger) { _logger = logger; } public void GetUser() { _logger.Log("Getting user..."); // Implement user retrieval logic } } ``` In this example, `ILogger` and `IUserService` are registered with scoped lifetime using `AddScoped`. This means that a new instance of the service will be created for each scope (e.g., each HTTP request in a web application). The `UserService` class depends on `ILogger`, which is injected through its constructor. This allows the `UserService` to use the `Logger` instance to log messages.