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

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

我使用lambda方法解决这个问题。

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

用例

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

Answer 3

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

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

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

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(system-type-system-object-)

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

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

8 个答案: