具有泛型构造函数的泛型类？

Question

I have a generic class. The constructor needs to accept an argument that is another instance of the same class. The problem is that the other instance can have a different generics type.

Looks like C# allows me to have a method with it's own generics type, but this doesn't appear allowed for the constructor.

public class MyClass<T>
{
    public MyClass<T2>(MyClass<T2> parent = null)
    {
    }

    // ... Additional stuff
}

The code above tells me T2 is undefined. It doesn't accept it as a method type.

One approach would be to add a second generic type to my class. But this is awkward and, in many cases, the argument will be null and there is not type.

Does anyone see a simple way around this?

Answer 1

You are correct. Generic constructors aren't supported.

You could probably try the following:

Create a lower level common interface

public interface IMyClass {
    //...some common stuff
    IMyClass Parent { get; set; }
}

And use that as the common link between the types

public class MyClass<T> : IMyClass {
    public MyClass(IMyClass parent = null) {
        Parent = parent;
    }
    public IMyClass Parent { get; set; }    
    // ... Additional stuff
}

Answer 2

Generic constructors aren't allowed. However, you can use a generic factory method instead.

public class MyClass<T>
{
    public int Id { get; private set; }
    public int? ParentId { get; private set; }

    public static MyClass<T> Create(int id)
    {
        return Create<object>(id, null);
    }

    public static MyClass<T> Create<T2>(int id, MyClass<T2> parent = null)
    {
        var current = new MyClass<T>();
        current.Id = id;
        current.ParentId = parent?.Id;
        return current;
    }

    private MyClass()
    {
    }

    // ... Additional stuff
}

Sample use:

var intClass = MyClass<int>.Create(55);
var charClass = MyClass<char>.Create(234, intClass);
// charClass.ParentId is 55

This is only possible if you do not need to access any generic members of parent outside the factory method. If you do, you'd be better off abstracting it through a non-generic interface or base class.