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

不。目前您可以指定的唯一构造函数约束是无参数构造函数。

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;
        }
    }
}

Answer 7

如何创建带有约束的泛型类，这里我选择了 struct 和 class 来具有值和引用类型。

这样你的构造函数就对值有约束。

 class MyGenericClass<T, X> where T :struct where X: class { private T genericMemberVariableT; private X genericMemberVariableX; public MyGenericClass(T valueT, X valueX) { genericMemberVariableT = valueT; genericMemberVariableX = valueX; } public T genericMethod(T genericParameter) { Console.WriteLine("Parameter type: {0}, value: {1}", typeof(T).ToString(), genericParameter); Console.WriteLine("Return type: {0}, value: {1}", typeof(T).ToString(), genericMemberVariableT); Console.WriteLine("Return type: {0}, value: {1}", typeof(X).ToString(), genericMemberVariableX); return genericMemberVariableT; } public T genericProperty { get; set; } }

执行：

 MyGenericClass<int, string> intGenericClass = new MyGenericClass<int, string>(10, "Hello world"); int val = intGenericClass.genericMethod(200);

Answer 8

这是 c# 维护者推荐的解决方法，如果您想保留构造函数参数，请间接调用构造函数：

            i = (TService)Activator.CreateInstance(typeof(TService), new object[] {arg});

其中 TService 是一个泛型，带有我想保留的全参数构造函数。

如果您想了解此方法的工作原理： https : //docs.microsoft.com/en-us/dotnet/api/system.activator.createinstance?view=net-5.0#system-activator-createinstance(系统类型系统对象-)

Aaaa 和 C# 维护者的讨论： https : //github.com/dotnet/csharplang/discussions/769