Is there a generic constructor with parameter constraint in C#?

Question

In C# you can put a constraint on a generic method like:

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

Where you specify that T should have a constructor that requires no parameters. I'm wondering whether there is a way to add a constraint like "there exists a constructor with a float[,] parameter?"

The following code doesn't compile:

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

A workaround is also useful?

Answer 1

As you've found, you can't do this.

As a workaround I normally supply a delegate that can create objects of type T:

public class A {

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

}

Answer 2

As of C# 11 / .NET 7 this can be accomplished by applying a constraint on an interface containing a static abstract factory creation method with the necessary arguments, then implementing the interface in all relevant types.

E.g., first define the following interface:

public interface ICreatable<TArgument, TResult>
{
    public abstract static TResult Create(TArgument arg);
}

Then, in your Method<T>, if you would like T to have a static factory method that takes a 2d float array, constrain it as follows:

public class A 
{
    public static void Method<T> (T a) where T : ICreatable<float[,], T>
    {
        var t = T.Create(new [,] { { 1f, 2f }, {3f, 4f} });
        //...do something...        
    }
}

Of course, any type you pass into Method<T> will need to implement ICreatable<float[,], T>, e.g. as follows:

public partial class Matrix2DFloat : ICreatable<float[,], Matrix2DFloat>
{
    readonly float[,] array;
    public Matrix2DFloat(float[,] array) => this.array = array ?? throw new ArgumentNullException(nameof(array));

    #region ICreatable<float[,], Matrix2DFloat> Members

    public static Matrix2DFloat Create(float[,] arg) => new Matrix2DFloat(arg);

    #endregion
}

Demo fiddle here.

Answer 3

No. At the moment the only constructor constraint you can specify is for a no-arg constructor.

Answer 4

There is no such construct. You can only specify an empty constructor constraint.

I work around this problem with lambda methods.

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

Use Case

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

Answer 5

Here's the recommended workaround by c# maintainers if you'd like to keep the constructor parameter-ful, call the constructor indirectly:

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

Where TService is a generic with a parameter-full constructor that I'd like to keep.

If you'd like to read up on how this method works: https://learn.microsoft.com/en-us/dotnet/api/system.activator.createinstance?view=net-5.0#system-activator-createinstance(system-type-system-object-)

Aaaaand discussion by maintainers of C#: https://github.com/dotnet/csharplang/discussions/769

Answer 6

How about creating your generic class with constraints, here I chose struct and class to have value and reference types.

That way your constructor has a constraint on the values.

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

Implementation:

var intGenericClass = new MyGenericClass<int, string>(10, "Hello world");

int val = intGenericClass.GenericMethod(200);

Answer 7

Using reflection to create a generic object, the type still needs the correct constructor declared or an exception will be thrown. You can pass in any argument as long as they match one of the constructors.

Used this way you cannot put a constraint on the constructor in the template. If the constructor is missing, an exception needs to be handled at run-time rather than getting an error at compile time.

// 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 8

As alternative (from C# 9+), you can define a interface with "init" properties, as you would to arguments of a constructor. One major benefit is it works for structs or classes.

using System;
                    
public class Program
{
    public interface ITest
    {
        int a { init; }
    }
    public struct Test : ITest{
        public int a { private get; init; }
        public int b => a;
    }   
    public static T TestFunction<T>() where T: ITest, new() {
        return new(){ a = 123 };
    }
    public static void Main()
    {
        var t = TestFunction<Test>();
        Console.WriteLine($"Hello World: {t.b}"); // Prints: Hello World: 123
    }
}

Answer 9

I think this is the most clean solution that kind of puts a constraint on the way an object is constructed. It is not entirely compile time checked. When you have the agreement to make the actual constructor of the classes have the same signature like the IConstructor interface, it is kind of like having a constraint on the constructor. The Constructor method is hidden when working normally with the object, because of the explicit interface implementation.

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 10

Here is a workaround for this that I personally find quite effective. If you think of what a generic parameterized constructor constraint is, it's really a mapping between types and constructors with a particular signature. You can create your own such mapping by using a dictionary. Put these in a static "factory" class and you can create objects of varying type without having to worry about building a constructor lambda every time:

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

then in your generic method, for example:

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