// 日志接口
public interface ILogger
{
    void Log(string message);
}

// 日志實現(xiàn)（文件日志）
public class FileLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine($"[FileLogger] {message}");
    }
}

// 用戶服務(wù)（依賴ILogger）
public class UserService
{
    // 傳統(tǒng)方式：自己創(chuàng)建依賴（緊耦合！如果要換數(shù)據(jù)庫日志，必須修改這里）
    private ILogger _logger = new FileLogger(); 

    public void AddUser(string username)
    {
        // 業(yè)務(wù)邏輯：添加用戶
        _logger.Log($"用戶 {username} 已添加"); // 使用日志
    }
}

// 調(diào)用
class Program
{
    static void Main()
    {
        UserService userService = new UserService();
        userService.AddUser("張三"); 
        // 輸出：[FileLogger] 用戶 張三 已添加
    }
}

// 新增一個數(shù)據(jù)庫日志實現(xiàn)
public class DatabaseLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine($"[DatabaseLogger] {message}");
    }
}

// 修改UserService：通過構(gòu)造函數(shù)接收依賴（依賴抽象，不依賴具體實現(xiàn)）
public class UserService
{
    private ILogger _logger;

    // 構(gòu)造函數(shù)注入：依賴由外部傳入，而非自己創(chuàng)建
    public UserService(ILogger logger)
    {
        _logger = logger; // 接收注入的日志對象
    }

    public void AddUser(string username)
    {
        _logger.Log($"用戶 {username} 已添加");
    }
}

// 調(diào)用：手動注入依賴（簡單場景下可手動管理，復雜場景用容器）
class Program
{
    static void Main()
    {
        // 1. 創(chuàng)建依賴對象（可替換為DatabaseLogger）
        ILogger logger = new FileLogger(); 
        // ILogger logger = new DatabaseLogger(); 

        // 2. 注入到UserService
        UserService userService = new UserService(logger); 
        userService.AddUser("張三"); 
        // 輸出：[FileLogger] 用戶 張三 已添加（換DatabaseLogger則輸出對應(yīng)內(nèi)容）
    }
}

using System;
using System.Collections.Generic;
using System.Reflection;

// 模擬IoC容器
public class SimpleIocContainer
{
    // 存儲注冊信息：key=接口類型，value=實現(xiàn)類型
    private Dictionary<Type, Type> _registry = new Dictionary<Type, Type>();

    // 注冊：接口 -> 實現(xiàn)
    public void Register<TInterface, TImplementation>() 
        where TImplementation : TInterface
    {
        _registry[typeof(TInterface)] = typeof(TImplementation);
    }

    // 解析：根據(jù)接口類型創(chuàng)建對象，并自動注入依賴
    public T Resolve<T>()
    {
        return (T)Resolve(typeof(T));
    }

    private object Resolve(Type type)
    {
        // 1. 如果是具體類型，直接創(chuàng)建（遞歸終止條件）
        if (!type.IsInterface)
        {
            return CreateInstance(type);
        }

        // 2. 如果是接口，查找注冊的實現(xiàn)類型
        if (!_registry.TryGetValue(type, out Type implementationType))
        {
            throw new Exception($"未注冊接口 {type.Name} 的實現(xiàn)");
        }

        // 3. 創(chuàng)建實現(xiàn)類的實例（并遞歸注入其依賴）
        return CreateInstance(implementationType);
    }

    // 通過反射創(chuàng)建對象，并注入構(gòu)造函數(shù)依賴
    private object CreateInstance(Type type)
    {
        // 獲取類型的構(gòu)造函數(shù)（簡化處理：取第一個構(gòu)造函數(shù)）
        ConstructorInfo ctor = type.GetConstructors()[0];
        // 獲取構(gòu)造函數(shù)的參數(shù)（依賴）
        ParameterInfo[] parameters = ctor.GetParameters();

        // 遞歸解析每個參數(shù)的依賴（如UserService的構(gòu)造函數(shù)參數(shù)是ILogger，解析ILogger）
        object[] parameterInstances = new object[parameters.Length];
        for (int i = 0; i < parameters.Length; i++)
        {
            parameterInstances[i] = Resolve(parameters[i].ParameterType);
        }

        // 創(chuàng)建對象（傳入解析好的依賴）
        return ctor.Invoke(parameterInstances);
    }
}

// 使用模擬容器
class Program
{
    static void Main()
    {
        // 1. 創(chuàng)建容器并注冊依賴
        SimpleIocContainer container = new SimpleIocContainer();
        container.Register<ILogger, FileLogger>(); // 注冊ILogger -> FileLogger
        // container.Register<ILogger, DatabaseLogger>(); // 可隨時切換實現(xiàn)

        // 2. 從容器解析UserService（容器自動注入ILogger）
        UserService userService = container.Resolve<UserService>();

        // 3. 調(diào)用方法
        userService.AddUser("李四"); 
        // 輸出：[FileLogger] 用戶 李四 已添加
    }
}