c# - 使用接口(interface)组合的异常奇怪的接口(interface)多态性

Question

在我正在处理的项目中，我最终得到了类似以下代码的东西。我觉得我被允许这样做真的很奇怪，但现在我开始怀疑是什么最有可能是我的架构失误导致我这样做的。

我的问题是:

• 这到底叫什么？
• 这在现实世界中有哪些用途？
• 为什么会有人想要这样做？

这是我的界面:

namespace ThisAndThat
{
    public interface ICanDoThis
    {
        string Do();
    }

    public interface ICanDoThat
    {
        string Do();
    }

    public interface ICanDoThisAndThat : ICanDoThis, ICanDoThat
    {
        new string Do();
    }
}

这是我的具体类:

namespace ThisAndThat
{
    public class CanDoThisAndThat : ICanDoThisAndThat
    {
        public string Do()
        {
            return "I Can Do This And That!";
        }

        string ICanDoThis.Do()
        {
            return "I Can Do This!";
        }

        string ICanDoThat.Do()
        {
            return "I Can Do That!";
        }
    }
}

以及我通过的测试:

using Xunit;

namespace ThisAndThat.Tests
{
    public class ThisAndThatTests
    {
        [Fact]
        public void I_Can_Do_This_And_That()
        {
            ICanDoThisAndThat sut = new CanDoThisAndThat();

            Assert.Equal("I Can Do This And That!", sut.Do());
        }

        [Fact]
        public void I_Can_Do_This()
        {
            ICanDoThis sut = new CanDoThisAndThat();

            Assert.Equal("I Can Do This!", sut.Do());
        }

        [Fact]
        public void I_Can_Do_That()
        {
            ICanDoThat sut = new CanDoThisAndThat();

            Assert.Equal("I Can Do That!", sut.Do());
        }

    }
}

Answer 1

这段代码绝对没有问题(前提是它不会让您的用户感到困惑)，而且它不是我熟悉的具有任何名称的模式。 CanDoThisAndThat实现两个接口(interface)，因此客户可以以任何一种方式使用它。

.NET 允许以这种方式实现接口(interface)——称为显式接口(interface)实现。

显式接口(interface)实现在以下情况下很有用:

1. 两个接口(interface)有相同的成员定义
2. 您需要实现一个接口(interface)，但不想公开某个特定成员可用于尚未使用该接口(interface)类型声明引用的客户端代码

.NET 框架中案例 2 的示例是 ICollection.SyncLock . List<T>工具 ICollection但是以下代码将无法编译，因为该成员已被故意“隐藏”，因为 BCL 的设计者不再提倡以这种方式锁定集合:

List<object> list = new List<object>();

lock (list.SyncRoot) // compiler fails here
{
    // ...
}

这种格式的任何旧代码仍然有效，因为引用的类型是 ICollection明确地:

ICollection list = new List<object>();

lock (list.SyncRoot) // no problem
{
    // ...
}