在C#中是否存在具有参数约束的通用构造函数？

Question

在C#中,您可以对通用方法设置约束,例如:

public class A {

    public static void Method<T> (T a) where T : new() {
        //...do something...
    }

}

您指定的T应该具有不需要参数的构造函数.我想知道是否有办法添加一个约束,如" 存在一个带float[,]参数的构造函数？ "

以下代码无法编译:

public class A {

    public static void Method<T> (T a) where T : new(float[,] u) {
        //...do something...
    }

}

解决方法也有用吗？

Answer 1

正如您所发现的那样,您无法做到这一点.

作为一种解决方法,我通常提供一个可以创建类型对象的委托T:

public class A {

    public static void Method<T> (T a, Func<float[,], T> creator) {
        //...do something...
    }

}

Answer 2

使用反射创建一个通用对象,该类型仍然需要声明正确的构造函数,否则将抛出异常.您可以传入任何参数,只要它们与其中一个构造函数匹配即可.

使用这种方式,您不能在模板中的构造函数上设置约束.如果缺少构造函数,则需要在运行时处理异常,而不是在编译时获取错误.

// public static object CreateInstance(Type type, params object[] args);

// Example 1
T t = (T)Activator.CreateInstance(typeof(T));
// Example 2
T t = (T)Activator.CreateInstance(typeof(T), arg0, arg1, arg2, ...);
// Example 3
T t = (T)Activator.CreateInstance(typeof(T), (string)arg0, (int)arg1, (bool)arg2);

Answer 3

没有这样的结构.您只能指定一个空构造函数约束.

我用lambda方法解决这个问题.

public static void Method<T>(Func<int,T> del) {
  var t = del(42);
}

用例

Method(x => new Foo(x));

Answer 4

这是一个解决方法,我个人觉得非常有效.如果您考虑泛型参数化构造函数约束是什么,它实际上是具有特定签名的类型和构造函数之间的映射.您可以使用字典创建自己的此类映射.将它们放在一个静态的"工厂"类中,你可以创建不同类型的对象,而不必担心每次都构建一个构造函数lambda:

public static class BaseTypeFactory
{
   private delegate BaseType BaseTypeConstructor(int pParam1, int pParam2);

   private static readonly Dictionary<Type, BaseTypeConstructor>
   mTypeConstructors = new Dictionary<Type, BaseTypeConstructor>
   {
      { typeof(Object1), (pParam1, pParam2) => new Object1(pParam1, pParam2) },
      { typeof(Object2), (pParam1, pParam2) => new Object2(pParam1, pParam2) },
      { typeof(Object3), (pParam1, pParam2) => new Object3(pParam1, pParam2) }
   };

然后在你的泛型方法中,例如:

   public static T BuildBaseType<T>(...)
      where T : BaseType
   {
      ...
      T myObject = (T)mTypeConstructors[typeof(T)](value1, value2);
      ...
      return myObject;
   }

Answer 5

不可以.目前唯一可以指定的构造函数约束是for-arg构造函数.

Answer 6

我认为这是对对象构造方式施加限制的最干净的解决方案。它没有完全检查编译时。当您同意使类的实际构造函数具有与 IConstructor 接口相同的签名时，这有点像对构造函数施加约束。Constructor由于显式接口实现，该方法在与对象正常工作时是隐藏的。

using System.Runtime.Serialization;

namespace ConsoleApp4
{
    class Program
    {
        static void Main(string[] args)
        {
            var employeeWorker = new GenericWorker<Employee>();
            employeeWorker.DoWork();
        }
    }

    public class GenericWorker<T> where T:IConstructor
    {
        public void DoWork()
        {
            T employee = (T)FormatterServices.GetUninitializedObject(typeof(T));
            employee.Constructor("John Doe", 105);
        }
    }

    public interface IConstructor
    {
        void Constructor(string name, int age);
    }

    public class Employee : IConstructor
    {
        public string Name { get; private set; }
        public int Age { get; private set; }

        public Employee(string name, int age)
        {
            ((IConstructor)this).Constructor(name, age);
        }

        void IConstructor.Constructor(string name, int age)
        {
            Name = name;
            Age = age;
        }
    }
}