C#の依存性注入を使ったモジュール管理の最適化ガイド

public interface IService
{
    void Serve();
}

public class Service : IService
{
    public void Serve()
    {
        Console.WriteLine("Service Called");
    }
}

public class Client
{
    private readonly IService _service;

    // Constructor Injection
    public Client(IService service)
    {
        _service = service;
    }

    public void Start()
    {
        _service.Serve();
    }
}

using Microsoft.Extensions.DependencyInjection;

var serviceProvider = new ServiceCollection()
    .AddTransient<IService, Service>()
    .AddTransient<Client>()
    .BuildServiceProvider();

var client = serviceProvider.GetService<Client>();
client.Start();

using Microsoft.Extensions.DependencyInjection;

var serviceCollection = new ServiceCollection();

// Transient: 新しいインスタンスを常に生成
serviceCollection.AddTransient<IService, Service>();

// Scoped: 同じスコープ内で同じインスタンスを使用
serviceCollection.AddScoped<IOtherService, OtherService>();

// Singleton: アプリケーション全体で同じインスタンスを使用
serviceCollection.AddSingleton<ISingletonService, SingletonService>();

var serviceProvider = serviceCollection.BuildServiceProvider();

var service = serviceProvider.GetService<IService>();
var client = new Client(service);
client.Start();

var client = serviceProvider.GetService<Client>();
client.Start();

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddTransient<IService, Service>();
        services.AddScoped<IOtherService, OtherService>();
        services.AddSingleton<ISingletonService, SingletonService>();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        // 中略
    }
}

public class HomeController : Controller
{
    private readonly IService _service;

    public HomeController(IService service)
    {
        _service = service;
    }

    public IActionResult Index()
    {
        _service.Serve();
        return View();
    }
}

services.AddTransient<IService, Service>();

services.AddScoped<IService, Service>();

services.AddSingleton<IService, Service>();

public class TransientService : ITransientService
{
    public void Execute()
    {
        // ロジック
    }
}

public class ScopedService : IScopedService
{
    public void Execute()
    {
        // ロジック
    }
}

public class SingletonService : ISingletonService
{
    public void Execute()
    {
        // ロジック
    }
}

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

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // サービスの登録
        services.AddTransient<IWeatherService, WeatherService>();
        services.AddScoped<IWeatherRepository, WeatherRepository>();
        services.AddControllers();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        app.UseRouting();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });
    }
}

public interface IWeatherService
{
    WeatherForecast GetForecast(DateTime date);
}

public class WeatherService : IWeatherService
{
    private readonly IWeatherRepository _weatherRepository;

    public WeatherService(IWeatherRepository weatherRepository)
    {
        _weatherRepository = weatherRepository;
    }

    public WeatherForecast GetForecast(DateTime date)
    {
        return _weatherRepository.FetchForecast(date);
    }
}

public interface IWeatherRepository
{
    WeatherForecast FetchForecast(DateTime date);
}

public class WeatherRepository : IWeatherRepository
{
    public WeatherForecast FetchForecast(DateTime date)
    {
        // データベースやAPIからのデータ取得ロジック
        return new WeatherForecast
        {
            Date = date,
            TemperatureC = 25,
            Summary = "Sunny"
        };
    }
}

[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{
    private readonly IWeatherService _weatherService;

    public WeatherForecastController(IWeatherService weatherService)
    {
        _weatherService = weatherService;
    }

    [HttpGet]
    public IEnumerable<WeatherForecast> Get()
    {
        var forecast = _weatherService.GetForecast(DateTime.Now);
        return new[] { forecast };
    }
}

public class BusinessLogic
{
    private readonly IDataAccess _dataAccess;

    public BusinessLogic(IDataAccess dataAccess)
    {
        _dataAccess = dataAccess;
    }

    public void ProcessData()
    {
        var data = _dataAccess.GetData();
        // ビジネスロジックの処理
    }
}

var serviceCollection = new ServiceCollection();

serviceCollection.AddTransient<IDataAccess, DataAccess>();
serviceCollection.AddTransient<BusinessLogic>();

var serviceProvider = serviceCollection.BuildServiceProvider();

var businessLogic = serviceProvider.GetService<BusinessLogic>();
businessLogic.ProcessData();

using Moq;
using Xunit;

public class BusinessLogicTests
{
    [Fact]
    public void ProcessData_Should_Call_GetData()
    {
        // モックの作成
        var mockDataAccess = new Mock<IDataAccess>();

        // ビジネスロジックにモックを注入
        var businessLogic = new BusinessLogic(mockDataAccess.Object);

        // メソッドの呼び出し
        businessLogic.ProcessData();

        // モックが期待通りに動作したかを検証
        mockDataAccess.Verify(m => m.GetData(), Times.Once);
    }
}

public class IntegrationTests
{
    private readonly ServiceProvider _serviceProvider;

    public IntegrationTests()
    {
        var serviceCollection = new ServiceCollection();

        // 依存関係の登録
        serviceCollection.AddTransient<IDataAccess, DataAccess>();
        serviceCollection.AddTransient<BusinessLogic>();

        _serviceProvider = serviceCollection.BuildServiceProvider();
    }

    [Fact]
    public void BusinessLogic_Should_ProcessData_Correctly()
    {
        var businessLogic = _serviceProvider.GetService<BusinessLogic>();
        businessLogic.ProcessData();

        // アサーション
    }
}

public class E2ETests
{
    private readonly IWebHost _webHost;

    public E2ETests()
    {
        _webHost = new WebHostBuilder()
            .UseStartup<Startup>()
            .UseTestServer()
            .Build();
    }

    [Fact]
    public async Task HomePage_Should_Return_HelloWorld()
    {
        var client = _webHost.GetTestClient();
        var response = await client.GetAsync("/");
        var responseString = await response.Content.ReadAsStringAsync();

        Assert.Equal("Hello, World!", responseString);
    }
}

name: CI

on:
  push:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - name: チェックアウトリポジトリ
        uses: actions/checkout@v2

      - name: .NET セットアップ
        uses: actions/setup-dotnet@v1
        with:
          dotnet-version: 5.0

      - name: 依存関係の復元
        run: dotnet restore

      - name: ビルドとテストの実行
        run: dotnet test --no-build --verbosity normal

var serviceCollection = new ServiceCollection();
serviceCollection.AddTransient<IService, Service>();
serviceCollection.AddScoped<IOtherService, OtherService>();
var serviceProvider = serviceCollection.BuildServiceProvider();

services.AddSingleton<IHeavyService, HeavyService>();

services.AddTransient<ILoggingService, LoggingService>();

services.AddScoped<IUserService, UserService>();

public class LazyServiceConsumer
{
    private readonly Lazy<IHeavyService> _heavyService;

    public LazyServiceConsumer(Lazy<IHeavyService> heavyService)
    {
        _heavyService = heavyService;
    }

    public void UseService()
    {
        var service = _heavyService.Value;
        service.PerformOperation();
    }
}

var serviceProvider = new ServiceCollection()
    .AddTransient<IService, Service>()
    .AddLogging(builder => builder.AddConsole().SetMinimumLevel(LogLevel.Debug))
    .BuildServiceProvider();

// 正しい例
services.AddSingleton<ISingletonService, SingletonService>();

// 誤った例（重複登録）
services.AddSingleton<ISingletonService, SingletonService>();
services.AddSingleton<ISingletonService, AnotherSingletonService>();

System.InvalidOperationException: Unable to resolve service for type 'IService' while attempting to activate 'MyClass'.

services.AddTransient<IService, Service>();

// シングルトンサービス
services.AddSingleton<ISingletonService, SingletonService>();

// スコープドサービスを避ける
services.AddScoped<IScopedService, ScopedService>(); // このような設定は避ける

public class ServiceA : IServiceA
{
    private readonly IServiceB _serviceB;

    public ServiceA(IServiceB serviceB)
    {
        _serviceB = serviceB;
    }
}

public class ServiceB : IServiceB
{
    private readonly IServiceA _serviceA;

    public ServiceB(IServiceA serviceA)
    {
        _serviceA = serviceA;
    }
}

// 解決方法：サービス間の依存を明確に分離する

// 重複登録の確認
services.AddSingleton<IMyService, MyService>();
// 重複登録を避ける
services.AddSingleton<IMyService, AnotherService>(); // これは避ける

public class SingletonService : ISingletonService
{
    private readonly object _lock = new object();

    public void PerformOperation()
    {
        lock (_lock)
        {
            // スレッドセーフな操作
        }
    }
}

var serviceProvider = new ServiceCollection()
    .AddTransient<IService, Service>()
    .AddLogging(builder => builder.AddConsole().SetMinimumLevel(LogLevel.Debug))
    .BuildServiceProvider();