针对多个接口进行编程

Question

我非常喜欢这个提示：“针对接口编程，而不是针对实现编程”，并且我一直在努力遵循它。然而，当我必须将我的代码与 必须 从多个接口继承的对象中分离时，我怀疑如何保持这一原则有效。一个典型的例子可能是：

namespace ProgramAgainstInterfaces
{
    interface IMean
    {
            void foo();
    }  

    class Meaning : IMean , IDisposable
    {
        public void Dispose()
        {
            Console .WriteLine("Disposing..." );
        }

        public void foo()
        {
            Console .WriteLine("Doing something..." );           
        }
    }

   class DoingSomething
   {
        static void Main( string[] args)
        {
            IMean ThisMeaning = (IMean ) new Meaning ();  // Here the issue: I am losing the IDisposable methods
            ThisMeaning.foo();
            ThisMeaning.Dispose();                     // Error: i cannot call this method losing functionality
        }
   }   
}

解决此问题的一种可能方法是定义一个继承自两个接口的 ad-hoc 接口：

namespace ProgramAgainstInterfaces
{
    interface IMean
    {
            void foo();
    }

    interface ITry : IMean , IDisposable
    {
    }

    class Meaning : ITry
    {
        public void Dispose()
        {
            Console .WriteLine("Disposing..." );
        }

        public void foo()
        {
            Console .WriteLine("Doing something..." );           
        }
    }

   class DoingSomething
   {
        static void Main( string[] args)
        {
            ITry ThisMeaning = (ITry ) new Meaning ();  // This works
            ThisMeaning.foo();
            ThisMeaning.Dispose();   // The method is available
        }
   }   
}

但我不确定这是否是更紧凑和更有效的解决方案：我可以拥有更复杂的多重继承层次结构，这会增加复杂性，因为我必须创建接口仅用作容器。有更好的设计方案吗？

Answer 1

代码到接口而不是实现 - “接口”是一个通用术语，它并不是字面上的关键字interface。使用abstract 类符合该原则。如果您需要一些实施，也许会更好。此外，子类总是可以根据需要实现interfaces。

Answer 2

您还可以引入必须实现多个接口的泛型类型T。以下是使用IFoo 和IDisposable 的示例：

class Program
{
    static void Main(string[] args)
    {
    }

    interface IFoo
    {
        void Foo();
    }

    class Bar<T> where T : IFoo, IDisposable
    {
        public Bar(T foo)
        {
            foo.Foo();
            foo.Dispose();
        }
    }
}

这有点复杂。如果IFoo : IDisposable 从设计的角度来看是错误的，这可能是有道理的。

Answer 3

当您的代码需要一个类型实现多个不同的接口时，这正是您通常必须做的。但是根据代码的语义，可能会发生很多变化。

例如，如果IMean 不一定是IDisposable，但有许多消费者确实要求他们的IMean 是一次性的，那么您自己提出的解决方案是可以接受的。您也可以使用抽象基类来执行此操作——“接口程序”不使用“接口”，如“interface 关键字定义的语言构造”，而是“对象的抽象版本”。

事实上，您可以要求您使用的任何类型都实现ITry（因此是一次性的），并简单地记录某些类型可以将Dispose 作为无操作实现。如果使用抽象基类，您还可以默认提供此无操作实现。

另一种解决方案是使用泛型：

void UseDisposableMeaning<T>(T meaning) where T : IMean, IDisposable
{
    meaning.foo();
    meaning.Dispose();
}

// This allows you to transparently write UseDisposableMeaning(new Meaning());

还有一种情况是消费者严格要求只需要IMean，但也需要具有一次性意识。你可以通过寻找类型来解决这个问题：

IMean mean = new Meaning();
var disposable = mean as IDisposable;
if (disposable != null) disposable.Dispose();

虽然这是一个可以接受的实用解决方案（特别是考虑到IDisposable 是“不仅仅是任何 界面”），但如果您发现自己一次又一次地这样做，您绝对应该退后一步；一般来说，任何形式的“类型转换”都被认为是不好的做法。

Answer 4

在这种情况下，您的替代方案似乎有点人为。让 IMean “实现” IDisposable。针对类进行编程并非每次都不好，我视情况而定。

Answer 5

如果作为“IMean”对象始终是一次性的，那么你应该让接口实现它：

public interface IMean : IDisposable
{
    ...
}

但是，如果让一个对象实现 IMean 而不是一次性的有意义，那么我认为您建议的解决方案是最好的：创建一个中间接口，以便您可以：

public interface IMean
{
    ...
}

public interface IDisposableMean : IMean, IDisposable
{
    ...
}

Answer 6

为了组合构建，您可以通过强制转换来检查对象是否支持特定的功能（接口）：

例如

// Try and cast
var disposable = ThisMeaning as IDisposable; 

// If the cast succeeded you can safely call the interface methods
if(disposable != null) 
    disposable.Dispose();

这意味着您在运行时发现实现，而不必在编译时知道它们，并且您的类型不需要实现IDisposable。

这满足了一次性要求，而不必知道IMean 的类型为Meaning（您仍然可以使用IMean refs）

Answer 7

您应该让interface 实现IDisposable 而不是类Meaning。这样，当投射到 interface 时，您不会失去 IDisposable 能力（因为它是在您的 interface 级别定义的）。

像这样：

namespace ProgramAgainstInterfaces
{
    interface IMean : IDisposable
    {
        void foo();
    }

    interface ITry : IMean
    {
    }

    class Meaning : ITry
    {
        public void Dispose()
        {
            Console .WriteLine("Disposing..." );
        }

        public void foo()
        {
            Console .WriteLine("Doing something..." );           
        }
    }

   class DoingSomething
   {
        static void Main( string[] args)
        {
            ITry ThisMeaning = (ITry ) new Meaning ();  // This works
            ThisMeaning.foo();
            ThisMeaning.Dispose();   // The method is available
        }
   }   
}