尝试创建 C# 方法，该方法输出嵌套在另一个泛型类型中的泛型类型的 object

Question

I'm currently working on writing a method that, for the sake of this problem, generates mazes.

Here's the (simplified) version of the classes involved:

public interface IAlgorithm<out MazeType> where MazeType : Maze
{
    MazeType GoGenerate();
}

public class AlgorithmBacktrack : IAlgorithm<Maze>
{
    public Maze GoGenerate()
    {
        //Do things
        return new Maze();
    }
}

public class Maze
{
}

public class MazeWithPath : Maze
{
}

What I'd like to do now is create helper to call this Algorithm:

public class MazeGenerator
{
    public static MAZETYPEGENERIC Generate<AlgorithmType>()
        where AlgorithmType : IAlgorithm<MAZETYPEGENERIC>, new()
    {
        var alg = new AlgorithmType();
        return alg.GoGenerate();
    }
}

The thing that I can't get to work though is the MAZETYPEGENERIC. Theoretically C# could know that whatever interface implementation of IAlgorithm I put in there would have the MAZETYPEGENERIC configured. However C# still want's me to add that as a Generic parameter to the method. Eg:

public static MAZETYPEGENERIC Generate<AlgorithmType, MAZETYPEGENERIC>()
    where AlgorithmType : IAlgorithm<MAZETYPEGENERIC>, new()
    ...

This however would mean that the invocation of this call would also require this parameter. Even though it could theoretically be inferred from the AlgorithmType.

//Ideal way to call this method:
Maze m = MazeGenerator.Generate<AlgorithmBacktrack>();

//Actual way to call this after adding the additional generic parameter:
Maze m = MazeGenerator.Generate<AlgorithmBacktrack, Maze>();

I would love to see/hear if someone has an idea on how to accomplish option 1 (the ideal way of doing this).

Answer 1

One way to do this is to accept an instance of IAlgorithm<MAZETYPEGENERIC> , and let type inference infer the type parameter MAZETYPEGENERIC . Now you wouldn't need the AlgorithmType type parameter

Maze m = MazeGenerator.Generate(new AlgorithmBacktrack());

...

public static MAZETYPEGENERIC Generate<MAZETYPEGENERIC>(IAlgorithm<MAZETYPEGENERIC> algorithm)
    where MAZETYPEGENERIC : Maze {
    return algorithm.GoGenerate();
}

You would have been able to access the type parameter of IAlgorithm if C# interfaces used associated types (like Swift), rather than generics. So it's not like this is completely impossible feature to have in a language. For a comparison see this post .

Answer 2

If "instantiate the Algorithm class" is all you need, the closest I can get is probably by moving the call to GoGenerate method out of Generate method, like this:

static T Generate<T>() where T : IAlgorithm<Maze>, new()
{
    return new T();
}

Maze m = MazeGenerator.Generate<AlgorithmBacktrack>().GoGenerate();
// I made the algorithm class up
MazeWithPath m = MazeGenerator.Generate<AlgorithmBacktrack2>().GoGenerate();

Or if the type of local variable m is always Maze , you could also do something like:

static Maze Generate<T>() where T : IAlgorithm<Maze>, new()
{
    return new T().GoGenerate();
}

Also want to comment on

Theoretically C# could know that whatever interface implementation of IAlgorithm I put in there

I hope C# would not (like it currently does). T in your case is covariant . If T is implementation of IAlgorithm<MazeWithPath> , both Maze , MazeWithPath and object are semantically correct for return type.

The compiler can't choose one without knowing the context of your code. And if it can, it may choose a wrong one for you:

// This is only correct when the compiler chooses MazeWithPath as return type
// It will become invalid if compiler chooses Maze or object
MazeWithPath m = Generate<AlgorithmBacktrack2>();

In saying that, making Generate method to take two generic parameters might make more sense IMO.