有没有更好的方法来过滤可以传递给继承类的构造函数的对象类型？

Question

我知道标题有点罗嗦，但我不知道该怎么问这个问题。这基本上是我用来过滤传递给继承类的对象类型的技术。先看代码，我再解释一下……

public interface IProjectile {}
public interface IPaintBall : IProjectile {}
public interface IPotato : IProjectile {}

public class Prop
{
    public void Shoot(params IProjectile[] projectiles)
    {
        // logic goes here...
    }
}

public class Car : Prop
{
    public override void Shoot(params IPaintBalls[] paintBalls)
    {
        base.Shoot(paintBalls);
    }
}

看到了吗？我不想让你用土豆射击我的车。你只能用彩弹射击它。那么我这样做是否正确？同样，当Prop 类有大约 100 个函数时，这变得更加复杂，我也想过滤到只是彩弹。我不想为Car 类写出那 100 多个函数，对吧？我特别不想为我将要编写的 100 多个 Car 类写出那 100 多个函数。

我在这里说得够清楚吗？

这只是一个例子。我不是在做游戏编程或类似的事情。我只是想给你们一个非常简单的例子来传达我想要的东西。基本上，如果有人试图将土豆传递给 Car 的 Shoot() 函数，我不希望代码编译。

Answer 1

我可能会做的是让 Prop 接受一个通用类型。即：

public class Prop<T> where T : IProjectile
{
    public virtual void Shoot(params T[] projectiles)
    {
        // logic goes here... 
    }
}

public class Car : Prop<IPaintBall>
{
    public override void Shoot(params IPaintBall[] projectiles)
    {
        base.Shoot(projectiles);
    }
} 

这些方法随后作为 PaintBalls 公开给 Car 类的用户，即：

Car car = new Car();
car.Shoot(somePaintballs); // Shoot will only take IPaintBall.

你也可以有一个非通用的 Prop 类：

public class Prop : Prop<IProjectile>
{
}

您仍然可以使用的地方：

public class Person : Prop
{
}

Person 可以与任何IProjectile 一起拍摄，包括IPotato。

Answer 2

如果我理解正确，我会选择泛型：

public interface IProjectile { }
public interface IPaintBall : IProjectile { }
public interface IPotato : IProjectile { }

public abstract class Prop<TProjectile> where TProjectile : IProjectile
{
    public void Shoot(params TProjectile[] projectiles)
    {

    }
}

public class Car : Prop<IPaintBall>
{

}

class Program
{
    static void Main(string[] args)
    {
        Car myCar = new Car();

        IPaintBall[] paintballs = PaintBallFactory.GetPaintBalls();

        myCar.Shoot(paintballs);
    }
}

那么你不能只用彩弹来调用 Car.Shoot。

Answer 3

我觉得没问题。重要的是，您使用了接口来抽象彩球的实现。

但是你的代码有点不对劲：

public override void Shoot(params IPaintBall[] paintBalls)
{
    base.Shoot(paintBalls);
}

更新：在这种情况下，使基类受保护并在派生类上公开一个新方法，但使用基实现。

public class Prop
{
    protected void Shoot(params IProjectile[] projectiles)
    {
        // logic goes here...  
    }
}

public class Car : Prop
{
    public void Shoot(params IPaintBall[] projectiles)
    {
        base.Shoot(projectiles);
    }
}  

未在编译器中测试，但我相信基本数组 ([]) 是协变的。

更新 2： 或者，定义一个负责拍摄的接口并为其提供 Shoot 方法。

public interface IProjectile { }
    public interface IPaintBall : IProjectile { }
    public interface IPotato : IProjectile { }
    public interface IShoot<T> where T : IProjectile
    {
        void Shoot(params T[] projectiles);
    }

    public interface IShootPaintBalls : IShoot<IPaintBall> { }

    public class Prop : IShoot<IProjectile>
    {
        public void  Shoot(params IProjectile[] projectiles)
        {
          // logic
        }
    }

    public class Car : Prop, IShootPaintBalls
    {
        public void  Shoot(params IPaintBall[] projectiles)
        {
            base.Shoot(projectiles);
        }
    }

更新 3： GenericTypeTea 的响应完成了泛型圈 :-)，我目前的解决方案不会阻止你用土豆射击汽车......

Answer 4

您不能在 .NET 中纯粹在编译时执行此操作。要实现一个接口，你必须实现它的所有方法。

但显式接口实现将允许您在一定程度上隐藏继承的IProjectile 方法，同时提供公共IPaintBalls 方法。

但是Prop 不会使Shoot 成为虚拟的，所以无论如何你都不能覆盖它。而Prop 是一个类而不是显式实现的接口，不适用。

看来你需要：

1. 使 Prop.Shoot 虚拟化，并且
2. 接受运行时检查。

类似这样的：

public class Prop {
  public virtual void Shoot(params IProjectile[] projectiles) {
    ...
  }
}

public class Car : Prop {
  public override void Shoot(params IProjectile[] projectiles) {
    foreach (var p in projectiles) {
      if (!(p is IPaintBall)) {
        throw new ArgumentException("Only shoot cars with paint balls");
      }
    }
    Shoot(projectiles.Cast<IPaintBall>().ToArray());
  }

  public virtual void Shoot(params IPaintBall[] balls) {
    // Allow callers that are calling with paint balls (know at compile time)
    // to come in directly.
  }
}

Answer 5

创建更多接口，在本例中为继承 IProjectile 的 IShootableProjectile。 Prop 也一样，这个类太笼统了。

不要创建可以做很多不同事情的接口或类。将它们分解为涵盖特定职责的小实体。详细了解以下设计原则：

http://blog.gauffin.org/2010/06/hello-world/