如何实现仅当指定DLL存在时类才继承对应接口？

我有一个类，希望仅当接口所在的commandInterface.dll文件存在时，才让该类继承这个接口。当DLL缺失时，程序仍能正常运行，且该类依然存在但不再继承接口。

示例代码 #

1. commandInterface.dll中的接口 #

public interface ICommand
{
    string GetName();
    string Run(string[] args);
}

2. main.exe中的当前类实现 #

public class TestCommand : ICommand
{
    public string GetName()
    {
        return "test";
    }
    
    public string Run(string[] args)
    {
        return args[0];
    }
}

可行解决方案 #

方法1：条件编译+抽象基类（编译时适配） #

这种方式适合在编译阶段就能确定是否引用目标DLL的场景：

1. 在主程序中定义一个与ICommand接口方法完全一致的抽象基类：

public abstract class CommandBase
{
    public abstract string GetName();
    public abstract string Run(string[] args);
}

2. 通过编译符号控制TestCommand的继承逻辑：

#if HAVE_COMMAND_INTERFACE
public class TestCommand : CommandBase, ICommand
#else
public class TestCommand : CommandBase
#endif
{
    public override string GetName()
    {
        return "test";
    }
    
    public override string Run(string[] args)
    {
        return args[0];
    }
}

• 编译时若引用了commandInterface.dll，添加编译符号HAVE_COMMAND_INTERFACE，类会同时继承基类和接口；未引用时则仅继承基类，DLL缺失时程序可正常启动。

方法2：反射+动态代理（运行时适配） #

如果需要在运行时动态判断DLL是否存在，可通过反射结合动态代理实现：

1. 让TestCommand默认独立存在，不继承外部接口：

public class TestCommand
{
    public string GetName()
    {
        return "test";
    }
    
    public string Run(string[] args)
    {
        return args[0];
    }
}

2. 程序启动时检查DLL状态，动态生成接口实现：

using System.IO;
using System.Reflection;
using Castle.DynamicProxy;

public static object GetCommandInstance()
{
    var dllPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "commandInterface.dll");
    if (File.Exists(dllPath))
    {
        var assembly = Assembly.LoadFrom(dllPath);
        var commandType = assembly.GetType("ICommand");
        var generator = new ProxyGenerator();
        var testCmd = new TestCommand();
        // 生成代理类将接口方法转发给TestCommand实例
        return generator.CreateInterfaceProxyWithoutTarget(commandType, new CommandInterceptor(testCmd));
    }
    else
    {
        return new TestCommand();
    }
}

// 拦截器实现方法转发逻辑
public class CommandInterceptor : IInterceptor
{
    private readonly TestCommand _target;
    public CommandInterceptor(TestCommand target) => _target = target;
    
    public void Intercept(IInvocation invocation)
    {
        switch (invocation.Method.Name)
        {
            case "GetName":
                invocation.ReturnValue = _target.GetName();
                break;
            case "Run":
                invocation.ReturnValue = _target.Run((string[])invocation.Arguments[0]);
                break;
        }
    }
}

• 无论DLL是否存在，TestCommand都能正常实例化；DLL存在时，可获取到实现ICommand的代理对象，供依赖接口的逻辑使用。

方法3：适配器模式（解耦类与接口） #

通过适配器解耦TestCommand与外部接口的直接关联：

1. 保持TestCommand独立，不继承ICommand：

public class TestCommand
{
    public string GetName()
    {
        return "test";
    }
    
    public string Run(string[] args)
    {
        return args[0];
    }
}

2. 当DLL存在时，编写适配器类实现ICommand并包装TestCommand（可通过条件编译控制适配器的编译）：

#if HAVE_COMMAND_INTERFACE
public class CommandAdapter : ICommand
{
    private readonly TestCommand _cmd;
    public CommandAdapter(TestCommand cmd) => _cmd = cmd;
    
    public string GetName() => _cmd.GetName();
    public string Run(string[] args) => _cmd.Run(args);
}
#endif

• 运行时根据DLL是否存在，决定是直接使用TestCommand，还是通过适配器将其转换为ICommand实例。

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