如何强制构造函数签名和静态方法？

Question

是否有办法强制（子）类在 C# 或 Java 中具有具有特定签名或特定静态方法的构造函数？

显然，您不能为此使用接口，而且我知道它会有用途有限。 我确实发现它很有用的一个例子是当您想要强制执行某些设计准则时，例如：

异常
它们都应该具有四个规范构造函数，但没有办法强制执行。 您必须依靠像 FxCop（C# 情况）这样的工具来捕获这些。

运营商
没有合同指定可以对两个类求和（在 C# 中使用运算符+）

是否有任何设计模式可以解决此限制？ 可以在语言中添加什么结构来克服 C# 或 Java 未来版本中的这一限制？

Answer 1

使用泛型，您可以强制类型参数具有无参数构造函数 - 但这就是它的限制。

除了泛型之外，即使存在这些限制，实际使用也会很棘手，但有时它对于类型参数/参数可能很有用。 在接口（或可能是静态接口）中允许静态成员同样可以帮助解决“通用数字运算符”问题。

我 写过这个 不久前遇到类似的问题。

Answer 2

在编译时没有强制执行，但我花了很多时间研究类似的问题； 一个支持通用的数学库，以及一个高效的（非-default) ctor API 均在 MiscUtil 中提供。 但是，这些仅在运行时首次使用时检查。 实际上这不是一个大问题 - 你的单元测试应该很快找到任何丢失的操作符/构造函数。 但它确实有效，而且很快......

Answer 3

您可以使用工厂模式。

interface Fruit{}

interface FruitFactory<F extends Fruit>{
   F newFruit(String color,double weight);

   Cocktail mixFruits(F f1,F f2);
}

然后，您可以为任何类型的 Fruit 创建类。

class Apple implements Fruit{}
class AppleFactory implements FruitFactory<Apple>{
   public Apple newFruit(String color, double weight){
       // create an instance
   }
   public Cocktail mixFruits(Apple f1,Apple f2){
       // implementation
   }
}

这并不强制您不能使用工厂以外的其他方式创建实例，但至少您可以指定从工厂请求哪些方法。

Answer 4

强制构造函数

你不能。 最接近的方法是将默认构造函数设为私有，然后提供一个具有参数的构造函数。 但它仍然存在漏洞。

class Base
{
  private Base() { }
  public Base(int x) {}
}

class Derived : Base
{
  //public Derived() { } won't compile because Base() is private
  public Derived(int x) :base(x) {}
  public Derived() : base (0) {} // still works because you are giving a value to base
}

Answer 5

该语言的问题在于静态方法实际上是二等公民（构造函数也是一种静态方法，因为您不需要实例来启动）。

静态方法只是具有命名空间的全局方法，它们并不真正“属于”它们定义的类（好吧，它们可以访问类中的私有（静态）方法，但仅此而已）。

编译器级别的问题是，如果没有类实例，就没有虚拟函数表，这意味着您无法使用所有继承和多态性内容。

我认为可以通过为每个类添加一个全局/静态虚拟表来使其工作，但如果尚未完成，可能有一个很好的理由。

Answer 6

如果我是一名语言设计师，我会解决这个问题。

允许接口包含静态方法、运算符和构造函数。

interface IFoo  
{  
  IFoo(int gottaHaveThis);  
  static Bar();  
}

interface ISummable
{
      operator+(ISummable a, ISummable b);
}

不允许相应的 new IFoo(someInt) 或 IFoo.Bar()

允许继承构造函数（就像静态方法一样）。

class Foo: IFoo
{
  Foo(int gottaHaveThis) {};
  static Bar() {};
}

class SonOfFoo: Foo 
{
  // SonOfFoo(int gottaHaveThis): base(gottaHaveThis); is implicitly defined
}

class DaughterOfFoo: Foo
{
  DaughhterOfFoo (int gottaHaveThis) {};
}

允许程序员强制转换为接口，并在必要时在运行时检查是否即使类没有明确指定，强制转换在语义上也是有效的。

ISummable PassedFirstGrade = (ISummable) 10; 

Answer 7

不幸的是你不能在 C# 中。 不过，这里有一个重拳：

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine(Foo.Instance.GetHelloWorld());
        Console.ReadLine();
    }
}

public class Foo : FooStaticContract<FooFactory>
{
    public Foo() // Non-static ctor.
    {
    }

    internal Foo(bool st) // Overloaded, parameter not used.
    {
    }

    public override string GetHelloWorld()
    {
        return "Hello World";
    }
}

public class FooFactory : IStaticContractFactory<Foo>
{
    #region StaticContractFactory<Foo> Members

    public Foo CreateInstance()
    {
        return new Foo(true); // Call static ctor.
    }

    #endregion
}

public interface IStaticContractFactory<T>
{
    T CreateInstance();
}

public abstract class StaticContract<T, Factory>
    where Factory : IStaticContractFactory<T>, new() 
    where T : class
{
    private static Factory _factory = new Factory();

    private static T _instance;
    /// <summary>
    /// Gets an instance of this class. 
    /// </summary>
    public static T Instance
    {
        get
        {
            // Scary.
            if (Interlocked.CompareExchange(ref _instance, null, null) == null)
            {
                T instance = _factory.CreateInstance();
                Interlocked.CompareExchange(ref _instance, instance, null);
            }
            return _instance;
        }
    }
}

public abstract class FooStaticContract<Factory>
    : StaticContract<Foo, Factory>
    where Factory : IStaticContractFactory<Foo>, new() 
{
    public abstract string GetHelloWorld();
}

Answer 8

好吧，我从你问题的措辞中知道你正在寻找编译时执行。 除非其他人有一个出色的建议/黑客允许您按照编译器暗示的方式执行此操作，否则我建议您可以编写一个自定义的 MSbuild 任务来执行此操作。 像 PostSharp 这样的 AOP 框架可能会通过其构建任务模型来帮助您在编译时完成此任务。

但是代码分析或运行时执行有什么问题呢？ 也许这只是偏好，我尊重这一点，但我个人对让 CA/FXCop 检查这些东西没有任何问题......如果你真的想强制你的类的下游实现者具有构造函数签名，你可以随时添加规则运行-使用反射检查基类构造函数的时间。

理查德

Answer 9

我不确定你想要达到什么目的，你能详细说明一下吗？ 在不同的类中强制使用特定的构造函数或静态方法的唯一原因是尝试在运行时动态执行它们，这是正确的吗？

构造函数旨在特定于特定类，因为它旨在初始化类的特定需求。 据我了解，您想要在类层次结构或接口中强制执行某些内容的原因是，它是与正在执行的流程相关的活动/操作，但在不同的情况下可能会有所不同。 我相信这是多态性的预期好处，这是使用静态方法无法实现的。

它还需要知道要为其调用静态方法的类的特定类型，这将打破接口或抽象类试图实现的行为差异的所有多态隐藏。

如果构造函数所表示的行为旨在成为这些类的客户端之间契约的一部分，那么我会将其显式添加到接口中。

如果类的层次结构具有类似的初始化要求，那么我将使用抽象基类，但是应该由继承类决定如何找到该构造函数的参数，其中可能包括公开类似或相同的构造函数。

如果这是为了允许您在运行时创建不同的实例，那么我建议在抽象基类上使用静态方法，该方法知道所有具体类的不同需求（您可以为此使用依赖注入）。