使用与多重继承相关的接口的任何真实示例

Question

我试图理解接口，以便我可以在我的程序中实现它们，但我无法想象应该如何使用它们。 还给我一些在 C# 中使用多重继承的例子

Answer 1

接口的一个很好的例子是存储库模式。您的接口将定义 Get、GetAll、Update、Delete 等方法。没有实现，只有函数签名。

然后，您可以编写该类的“具体”实现来与 MySQL 等一起使用。不过，您的 UI 应该仅指界面。

稍后，如果您决定更改为 Microsoft SQL，则可以编写另一个具体实现，但您的 UI 代码不必进行（太多）更改。

C# 中不存在多重继承，即只能从一个“具体”类继承；尽管您可以继承（或“实现”）任意数量的接口。

Answer 2

我正在写一个视频游戏。在这个视频游戏中，我对游戏中的物体施加了不同的力。推力、冲击力、重力。虽然它们的计算方式不同，但它们都具有相同的基本要素。我需要调用一个更新函数来评估力并将力添加到它所附加的对象上。

因此，我所做的是创建一个 IForce 接口，该接口具有签名更新功能。我的所有力量都实现了这个接口：

public interface IForce
{
    void Update(Particle particle, GameTime gameTime);
}

这是一个示例实现。

public class Spring : IForce
{
    private Particle ThisParticle;
    private Particle ThatParticle;

    private float K;

    public Spring(Particle thisParticle, Particle thatParticle, float k)
    {
        ThisParticle = thisParticle;
        ThatParticle = thatParticle;
    }

    public void Update(Particle particle, GameTime gameTime)
    {            
        float X = Vector3.Length(ThisParticle - ThatParticle);

        ThisParticle.Forces.Add(K * X);
    }
}

更新函数有一个简化的弹簧力更新，更容易理解。

这在几个方面都有帮助。

我可以完全改变力的计算方式，而不会影响代码的其他部分。我一直这样做。同样，对我来说，添加新的力量也是极其容易的。只要它实现了 IForce 接口，我知道它就能与我现有的代码很好地配合。

它的另一种帮助方式是处理大量的力量。我有一个强制注册表，其中包含 IForce 列表。由于所有部队都实现该接口并具有更新功能，因此很容易更新游戏中的所有部队。当我创建力量时，我将其添加到列表中。然后，我循环遍历列表并调用每个元素更新函数，而不用担心它是什么类型的力以及我所有的力都会更新。

我每天都会在很多不同的情况下使用界面。他们太棒了！

Answer 3

注意：接口用于不惜一切代价限制和访问不同类的方法或事件等，这意味着我们可以在任何类中定义更多方法，但是当我们通过接口调用方法时，意味着我们只需要受限制的方法之外的方法。在下面的程序中，User1 可以使用 Read &两者均可写入，但 User2 可以写入和执行。请参阅下面的程序......

namespace ExplConsole
{
    class Program 
    {
        static void Main ()
        {
            System.Console.WriteLine("Permission for User1");
            User1 usr1 = new Test(); // Create instance.
            usr1.Read(); // Call method on interface.
            usr1.Write();
            System.Console.WriteLine("Permission for User2");
            User2 usr2 = new Test();
            usr2.Write();
            usr2.Execute();
            System.Console.ReadKey();
        }
    }
    interface User1
    {
        void Read();
        void Write();
    }
    interface User2
    {
        void Write();
        void Execute();
    }
    class Test : NewTest,User1, User2 
    {
        public void Read()
        {
            Console.WriteLine("Read");
        }
        public void Write()
        {
            Console.WriteLine("Write");
        }
    }
    class NewTest 
    {
        public void Execute()
        {
            Console.WriteLine("Execute");
        }
    }
}

输出：

    Permission for User1
    Read
    Write
    Permission for User2
    Write
    Execute

Answer 4

接口只是定义对象的公共元素（例如属性、方法、事件）的契约，而不是行为。

interface IDog
{
    void WagTail();    //notice no implementation
    ISound Speak();    //notice no implementation
}

class Spaniel : IDog
{
    public void WagTail()
    {
        Console.WriteLine("Shook my long, hairy tail");
    }

    public ISound Speak()
    {
        return new BarkSound("yip");
    }

}

class Terrier : IDog
{
    public void WagTail()
    {
        Console.WriteLine("Shook my short tail");
    }

    public ISound Speak()
    {
        return new BarkSound("woof");
    }
}

更新

在“真实示例”中，我使用以下接口：
- 单元测试
- 通用（例如存储库、网关、设置）

interface Repository<T>{
    T Find(Predicate<T>);
    List<T> ListAll();
}

interface Gateway<T>{
    T GetFrom(IQuery query);
    void AddToDatabase(IEntity entityItem);
}

interface Settings<T>{
    string Name { get; set; }
    T Value { get; set; }
    T Default { get; }
}

Answer 5

这是一个（在 Java 中，但这并不重要，因为它们很相似）：
在我的项目中，我创建了简单的界面：

public interface Identifiable<T> {
    public T getId();
}

这是对某些类型注释的简单替换。下一步：我已经让所有实体类都实现了这个接口。

第三步是编写一些类似语法糖的方法：

public <T> List<T> ids(List<? extends Identifiable<T> entities) { ... }

这只是一个示例。

更复杂的示例类似于验证规则：您有一些验证引擎（可能由您编写）和一个简单的规则接口：

public interface ValidationRule {
    public boolean isValid(...);
}

因此，该引擎需要您实现规则。当然，还会有多重继承，因为您肯定希望不止一个规则。

Answer 6

多重继承是指让一个类可以在多种情况下使用：[伪代码]

interface Shape {
    // shape methods like draw, move, getboundingrect, whatever.
}

interface Serializable {
    // methods like read and write
}

class Circle : public Shape, public Serializable {
    // TODO: implement Shape methods
    // TODO: implement Serializable methods
}

// somewhere later
{
    Circle circle;
    // ...
    deserializer.deserialize(circle);
    // ...
    graphicsurface.draw(circle);
    // ...
    serializer.serialize(circle);
}

这个想法是，您的 Circle 类实现了两个不同的接口，这些接口在非常不同的情况下使用。

Answer 7

有时太抽象只会造成妨碍，而参考实现细节实际上可以澄清事情。因此，我将提供接口的接近金属的解释，使我最终理解它们。

接口只是声明类实现一些虚函数以及这些虚函数应如何在类的 vtable。当您声明接口时，实际上是向编译器提供了虚拟函数表的高级描述。当你实现一个接口时，你就告诉编译器你想要在你的类中包含该接口引用的虚函数表。

接口的目的是您可以将实现接口 I 的类隐式转换为接口 I 的实例：

interface I {
    void doStuff();
}

class Foo : I {
    void doStuff() {}

    void useAnI(I i) {}
}

var foo = new Foo();
I i = foo;  // i is now a reference to the vtable pointer for I in foo.
foo.useAnI(i);  // Works.  You've passed useAnI a Foo, which can be used as an I.

Answer 8

在我看来，我自己对接口有些陌生，简单的答案是在类中实现接口本质上意味着：“这个类必须在接口中定义函数（和参数）”。

由此可见，每当某个类实现该接口时，您就可以确保能够调用这些函数。

如果多个不同的类实现相同的接口，您可以将它们全部“强制转换”到接口并调用它们上的所有接口函数，这可能会产生不同的效果，因为每个类可能有不同的函数实现。

例如，我一直在创建一个程序，允许用户生成 4 种不同类型的地图。为此，我创建了 4 种不同类型的生成器类。不过，它们都实现了“IGenerator”接口：

public interface IGenerator {
    public void generateNow(int period);
}

这告诉它们至少定义一个“publicgenerateNow(int period)”函数。

无论我最初拥有什么生成器，在将其转换为“IGenerator”后，我都可以对其调用“generateNow(4)”。我不必确定我返回的生成器类型，这本质上意味着在巨大的 if 语句中不再有“variable instanceof Class1”、“variable instanceof Class2”等。

Answer 9

看一下您熟悉的东西 - 即 C# 中的 List 集合。列表定义 IList 接口，通用列表定义 IList 接口。 IList公开了诸如Add、Remove之类的函数，并且List实现了这些函数。还有一些 BindingList 以稍微不同的方式实现 IList。

我还推荐Head First设计模式。代码示例采用 Java 语言，但很容易翻译成 C#，而且它们还将向您介绍接口和设计模式的真正威力。