C# 是否有可能绕过接口继承中使用的传递闭包？

使用接口继承，我希望在终端接口/类中有来自all祖先的all项，并且我还希望为所有派生接口/对象（继承树根）有一个基本接口，用于像

进程（IBase b）

这样的一般对象处理。因此，例如，与此相反：

public interface IBase 
{
    Guid Id {get;} 
    void SwitchOn();
}

public interface IPart1 : IBase {void DoPart1Specific();}
public interface IPart2 : IBase {void DoPart2Specific();}
public interface ICompound1 : IPart1, IPart2 {}

public class Compound : ICompound1
{
    public Guid Id => Guid.Empty;        // IBase
    public void SwitchOn() {}            // IBase
    public void DoPart1Specific() {}     // IPart1
    public void DoPart2Specific() {}     // IPart2
}

我希望有这样的东西（使用伪显式接口实现符号，这在这里当然不起作用）：

我能找到的唯一不太好的部分解决方案是复制每个接口定义中的所有公共内容，这太冗长且容易出错（在这种情况下，显式实现可以工作，并且可以说，

复合

类成员不能公开并不重要），但没有可用的基本接口）o:

---

看起来您根本不想从接口继承，而是使用组合。您的复合类需要包含Part1的一个实例和Part2的一个实例。这将产生如下结果：

public interface IPart {
    Guid Id { get; }
    void SwitchOn();
    void Execute();
}

public class Compound
{
    private readonly IPart _part1;
    private readonly IPart _part2;

    public Compound(IPart part1, IPart part2)
    {
        _part1 = part1;
        _part2 = part2;
    }

    public Guid Part1Id { get { return _part1.Id; } }
    public void Part1SwitchOn() { _part1.SwitchOn(); }
    public void DoPart1Specific() { _part1.Execute(); }

    public Guid Part2Id { get { return _part2.Id; } }
    public void Part2SwitchOn() { _part2.SwitchOn(); }
    public void DoPart2Specific() { _part2.Execute(); }
}

或者更简单的类就是：

public class Compound
{
    public Compound(IPart part1, IPart part2)
    {
        Part1 = part1;
        Part2 = part2;
    }

    public IPart Part1 { get; private set; }
    public IPart Part2 { get; private set; }
}

然后使用以下命令在调用代码中访问它们：

var compound = MyMethodWhichCreatesCompound();
var id1 = compound.Part1.Id;
compound.Part2.Execute();
//etc

---

我认为在接口成员定义中使用

new

关键字可以帮助您：

public interface IBase 
{
    Guid Id {get;} 
    void SwitchOn();
}

public interface IPart1 : IBase
{
    new Guid Id {get;}
    new void SwitchOn();
    void DoPart1Specific();
}

public interface IPart2 : IBase
{
    new Guid Id {get;}
    new void SwitchOn();
    void DoPart2Specific();
}

---

你说你想“为像

Process（IBase b）

”这样的一般对象处理而做”，但是，如果你调用

Process（newcomponent（））

，

Process

是如何知道

IBase

已经实现了两次（或更多）的呢并使用所有实现执行所有处理？这是一个非常好的问题，它给我的计划带来了一些黑暗。。。我将尝试将其投影到实际情况。删除上述要求。即使在C++中考虑允许多重继承，我也无法判断它是否可能，或者对于实际场景是有意义的。将尝试重新思考整个问题，并可能引入更多的组合，而不是多重接口…是的，对于给定的示例，组合是最好的。有两个连续不断发展的相互矛盾的需求，我在示例中使用的复合对象是整个系统中比较棘手的部分。下一次，在发布令人困惑的问题之前，我会三思而后行；-）

var compound = MyMethodWhichCreatesCompound();
var id1 = compound.Part1.Id;
compound.Part2.Execute();
//etc

public interface IBase 
{
    Guid Id {get;} 
    void SwitchOn();
}

public interface IPart1 : IBase
{
    new Guid Id {get;}
    new void SwitchOn();
    void DoPart1Specific();
}

public interface IPart2 : IBase
{
    new Guid Id {get;}
    new void SwitchOn();
    void DoPart2Specific();
}