在类型上强制执行静态方法

Question

我希望一个类具有一个名为 GetProduct 的强制静态方法，以便客户端代码可以接受类型并在检查传递的类型是否实现名为 ICommandThatHasProduct 的接口后安全地调用该静态方法。

看来这是不可能的，所以现在我正在寻求帮助来找到实现这一目标的方法。我知道我可以使用反射来查看我传递的类型是否包含名为“GetProduct”的方法，但我希望有一种更面向对象的方式（即使用继承）。

任何帮助将不胜感激！下面的代码是伪c#，肯定无法编译。

public interface ICommandThatHasProduct
{
    object GetProduct(int id);
}

public abstract class Command : ICommandThatHasProduct
{
    // I want to be able to make the GetProduct method static
    // so that calling code can safely call it
    public static object GetProduct(int id)
    {
        // do stuff with id to get the product
    }

    public object Execute()
    {
        CommandWillExecute();
    }

    public abstract object CommandWillExecute();
}

public class Program
{
    public Program(Type type, int productId)
    {
        if(type == ICommandThatHasProduct)
        {
            // Create the args
            var args = object[1]{ productId };

            // Invoke the GetProduct method and pass the args
            var product = type.InvokeMethod("GetProduct", args);

            //do stuff with product
        }

        throw new Execption("Cannot pass in a Command that does not implement ICommandHasProduct");
    }
}

Answer 1

方法不必是静态的。请改用成员方法，并创建通常的继承树。

我猜您正在寻找 抽象工厂 或 C# 中的简单工厂方法模式实现。

请牢记LSP。它有助于避免看起来奇怪的继承树。

Answer 2

我希望一个类有一个名为 GetProduct 的强制静态方法，以便客户端代码可以接受 Type 对象，并在检查传递的类型是否实现接口后安全地调用该静态方法。

您将通过反射进行调用，因此您也必须通过反射进行执行。反射的全部要点是在运行时执行编译器无法验证的工作；如果您想要的是编译时验证，那么您使用的工具完全错误。如果您确实想要这样做，请不要使用专门设计来击败编译时验证的工具！

我希望有一种更面向对象的方式（即使用继承）。

您正在以面向对象的方式进行操作。面向对象是以对象的形式传递功能单元，并向它们发送“消息”（也称为方法调用），描述您想要对它们执行什么操作，以及稍后分析这些“消息”绑定时尚。 （通常后期绑定采用虚拟调用的形式，但通过名称进行后期绑定也可以。）

继承是一种在类之间共享代码并表示语义“是一种”关系的机制；为什么您认为继承与您的问题相关？

Answer 3

我认为你真正的问题是你传递的是 Type 而不是你自己的类。 GetProduct() 方法实际上属于表示命令类型的类，但当然您不能在实际的 Type 上添加该方法。因此，请创建自己的类来表示命令的类型。

我猜您正在使用 Type 通过反射构造实际的 Command。如果是这样，您实际上需要一个“工厂”。 （如果创建工厂没有意义，只需创建一个“CommandType”对象即可）。

尝试这样的事情：

public interface IFactory{
  object Create();
}

public interface IFactoryThatHasProduct: IFactory
{
  object GetProduct(int id);
}

public class MyCommand
{
  //...
}

public class MyCommandFactory:IFactoryThatHasProduct
{
  object Create(){
    return new MyCommand();
  }

  object GetProduct(int id){
    return //TODO
  }
}

public class Program
{
  public Program(IFactory factory, int productId)
  {
    // consider just having the method take IFactoryThatHasProduct instead of IFactory
    if(factory is IFactoryThatHasProduct){
      var factoryThatHasProduct = (IFactoryThatHasProduct) factory;
      var product = factoryThatHasProduct.GetProduct(productId);
    }
    else{
      throw new Exception("Cannot pass in a factory that does not implement IFactoryThatHasProduct");
    }
  }
}

}

Answer 4

考虑到关于这是否是正确的方法的评论，我假设您知道自己在做什么。这是一个最小的代码示例：

using System;
using System.Reflection;

namespace EnforceStaticMethod
{
class Program
{
    static void Main()
    {
        var objA = GetProduct(typeof (TypeA), 1);
        var objB = GetProduct(typeof (TypeB), 2);

        Console.WriteLine("objA has type: " + objA.GetType());
        Console.WriteLine("objB has type: " + objB.GetType());
    }

    static object GetProduct(Type type, int id)
    {
        var argTypes = new[] {typeof (int)};
        var method = type.GetMethod("GetProduct", BindingFlags.Static | BindingFlags.Public, null, argTypes, null);
        if (method == null)
        {
            throw new ArgumentException("Type does not have GetProduct method: " + type);
        }

        var args = new object[] {id};
        return method.Invoke(null, args);
    }
}

class TypeA
{
    public static object GetProduct(int id)
    {
        return new TypeA();
    }
}

class TypeB
{
    public static object GetProduct(int id)
    {
        return new TypeB();
    }
}
}

Answer 5

为什么需要静态调用它？您可以这样做：

public class Client 
{
    public void DoSomethingWith<T>() where T : ICommandThatHasProduct, new()
    {
        var command = new T();
        var products = command.GetProducts();
    }
}

或者只是这样：

public class Client 
{
    public void DoSomethingWith(ICommandThatHasProduct command)
    { 
        var products = command.GetProducts();
    }
}

您始终可以将实例而不是类型传递给客户端。