Question

让我们说，我有一个抽象的2类接口：

public abstract class Entity
{
    public abstract void Interact(Entity entity);
}

public interface IFoo 
{
    void DoFoo();
}

public interface IBar
{
    void DoBar();
}

现在，假设我有两个实现这些接口的类：

public class Foo : Entity, IFoo
{
    public override void Interact(Entity entity)
    {
        // do something with entity...
    }

    public void DoFoo()
    {
       // Do foo stuff here..
    }
}

public class Bar : Entity, IBar
{
    public override void Interact(Entity entity)
    {
        // do something with obj..
    }

    public void DoBar()
    {
       // Do bar stuff here..
    }
}

现在的问题是，由于这些类实现了相同的抽象类（Entity），Bar可以与Foo进行交互，反之亦然，如下所示：

var foo = new Foo();
var bar = new Bar();

foo.Interact(bar); // OK!
bar.Interact(foo); // OK too!

但是现在，我希望Foo只能与IFoo的另一个实例进行交互，如果它尝试与Bar的实例进行交互，则会产生编译时错误，同样的规则应该也适用于Bar。所以它应该是......

var foo = new Foo();
var anotherFoo = new Foo();
var bar = new Bar();

foo.Interact(anotherFoo); // OK!
foo.Interact(bar); // give compile time error
bar.Interact(foo); // this one should give compile time error too

有可能做这样的事吗？如果是这样，我该怎么做？

Answer 1

你在这里混淆了一些元素

实体与IFoo或IBar没有任何关系 Foo与Entity和IFoo有关系 Bat与Entity和IBar有关系

所以如果你只想与IFoo交互，那么你需要指定IFoo作为父实体

public class Foo : Entity, IFoo
{
    public void Interact(IFoo entity)
    {
        // do something with entity...
    }

    public void DoFoo()
    {
       // Do foo stuff here..
    }
}

public class Bar : Entity, IBar
{
    public void Interact(IBar entity)
    {
        // do something with obj..
    }

    public void DoBar()
    {
       // Do bar stuff here..
    }
}

由于交互行为不是由其所有子项共享，因此交互不属于父

你可以通过泛型来解决这个问题

public abstract class Entity<T>
 where T:Entity
{
    void Interact(T entity);
}

这将允许您将foo声明为

public class Foo : Entity<Foo>, IFoo
{
    public override void Interact(Foo entity)
    {
        // do something with entity...
    }

    public void DoFoo()
    {
       // Do foo stuff here..
    }
}

如果两个类没有实现相同的接口，则给出编译时错误

1 个答案: