如何基于逻辑实例化编译时未知的抽象类子类？附构造传参疑问

我刚好处理过几乎一模一样的需求，结合Amir Popovich的思路，给你整理一套既能满足“新增设备无需修改核心代码”，又能解决构造函数参数传递问题的实现方案。

核心思路 #

我们要实现开闭原则——核心的实例化逻辑对扩展开放、对修改关闭。核心步骤是：

• 用特性/标记接口标记所有设备子类，关联设备识别标识
• 程序启动时扫描所有设备子类，缓存“设备标识→子类类型”的映射
• 识别到设备后，从缓存中取出对应类型，动态实例化并处理构造函数参数

具体实现步骤 #

1. 定义抽象基类与标记特性 #

先给所有设备子类定义统一的抽象基类，再用特性绑定设备识别标识：

public abstract class DeviceBase
{
    // 设备通用方法/属性
    public abstract void Initialize();
}

// 用于标记设备子类对应的识别标识
[AttributeUsage(AttributeTargets.Class, Inherited = false)]
public class DeviceTypeAttribute : Attribute
{
    public string Identifier { get; }

    public DeviceTypeAttribute(string identifier)
    {
        Identifier = identifier;
    }
}

2. 实现设备子类并标记特性 #

新增设备时，只需要继承基类并添加特性，完全不用碰核心实例化代码：

[DeviceType("Printer_X1")]
public class PrinterX1 : DeviceBase
{
    // 带参数的构造函数示例
    private readonly ILogger<PrinterX1> _logger;
    public PrinterX1(ILogger<PrinterX1> logger)
    {
        _logger = logger;
    }

    public override void Initialize()
    {
        _logger.LogInformation("Printer X1 initialized");
    }
}

[DeviceType("Scanner_Y2")]
public class ScannerY2 : DeviceBase
{
    // 无参构造函数示例
    public override void Initialize()
    {
        Console.WriteLine("Scanner Y2 initialized");
    }
}

3. 预缓存设备类型映射 #

程序启动时扫描程序集，把所有设备子类和对应的标识缓存起来，避免每次实例化都扫描，提升性能：

private readonly Dictionary<string, Type> _deviceTypeMap = new();

public void InitializeDeviceMap()
{
    // 扫描当前程序集中所有DeviceBase的子类
    var deviceTypes = Assembly.GetExecutingAssembly()
        .GetTypes()
        .Where(t => typeof(DeviceBase).IsAssignableFrom(t) && !t.IsAbstract);

    foreach (var type in deviceTypes)
    {
        var attribute = type.GetCustomAttribute<DeviceTypeAttribute>();
        if (attribute != null)
        {
            _deviceTypeMap.Add(attribute.Identifier, type);
        }
    }
}

4. 核心实例化循环（含构造函数参数处理） #

这是你最关心的内部循环实现，这里解决了不同构造函数参数的传递问题——我这里用依赖注入容器（比如ASP.NET Core的IServiceProvider）来解析参数，如果你没有用DI容器，也可以自定义参数解析逻辑：

private readonly IServiceProvider _serviceProvider;

// 假设通过构造函数注入服务提供者
public DeviceFactory(IServiceProvider serviceProvider)
{
    _serviceProvider = serviceProvider;
    InitializeDeviceMap();
}

public List<DeviceBase> GetConnectedDeviceInstances()
{
    var connectedDevices = GetConnectedDevices(); // 你的设备识别逻辑，返回带标识的设备列表
    var deviceInstances = new List<DeviceBase>();

    foreach (var device in connectedDevices)
    {
        if (_deviceTypeMap.TryGetValue(device.Identifier, out var deviceType))
        {
            DeviceBase instance;
            // 获取构造函数信息，这里取第一个构造函数（也可以根据参数匹配）
            var constructor = deviceType.GetConstructors().First();
            
            try
            {
                // 解析构造函数所需的所有参数
                var parameters = constructor.GetParameters()
                    .Select(param => _serviceProvider.GetService(param.ParameterType))
                    .ToArray();
                
                // 实例化对象
                instance = (DeviceBase)Activator.CreateInstance(deviceType, parameters);
                deviceInstances.Add(instance);
            }
            catch (Exception ex)
            {
                // 处理实例化异常，比如日志记录
                Console.WriteLine($"Failed to instantiate {deviceType.Name}: {ex.Message}");
            }
        }
        else
        {
            Console.WriteLine($"No device type found for identifier: {device.Identifier}");
        }
    }

    return deviceInstances;
}

// 模拟你的设备识别方法
private IEnumerable<ConnectedDevice> GetConnectedDevices()
{
    // 返回已识别的设备列表，每个设备带Identifier属性
    yield return new ConnectedDevice { Identifier = "Printer_X1" };
    yield return new ConnectedDevice { Identifier = "Scanner_Y2" };
}

关键优势 #

• 无需修改核心代码：新增设备时，只需要添加带特性的子类，GetConnectedDeviceInstances逻辑完全不用动
• 灵活处理构造函数参数：不管子类是无参还是带依赖参数，都能通过DI容器自动解析，不用硬编码参数
• 性能优化：提前缓存类型映射，避免每次循环都扫描程序集

内容的提问来源于stack exchange，提问作者tsxp