.NET Core Cast与具有实现接口的类型的通用类型参数的接口

Question

In .NET Core C# I' trying something like this:

(IInterface<IParameter>)instance

Where instance is new Implementation<Parameter>()

And Implementation : IInterface & Parameter : IParameter

The issue is with the casting of the generic parameter. When I provide Parameter instead of IParameter it works but at compile time there is no way to know which type that implements IParameter will be used. All of these objects will be created via reflection.

So is there any way this cast works? Or some other way to implement this like providing no generic type parameter like you can with typeof .

EDIT Thanks to Ziriax

A Fully Working Example:

interface IInterface
{
    void Run(TInput input);
}

abstract class AbstractClass<TInput> : IInterface
    where TInput : IParameter
{
    public abstract void Execute(TInput input);

    public void Run(IParameter input)
    {
        Execute((TInput)input);
    }
}

interface IParameter {}

class Implementation : AbstractClass<Parameter>
{
    public void Run(Parameter input)
    {
    }
}

class Parameter : IParameter {}

class Program
{
    static void Main()
    {
        object instance = new Implementation();
        var castInstance = (IInterface) instance;
        castInstance.Run(new Parameter());
    }
}

Answer 1

As you have it now, this cannot work. Your Implementation class implements IInterface<Parameter> , so its Run method only accepts a parameter of the concrete Parameter type, whereas the IInterface<IParameter> requires that its Run method accepts an instance of any type that implements IParameter .

If the type of cast you're trying to do were allowed, I could define a different class that implements IParameter , eg:

public class DifferentParameter : IParameter { ... }

And then do:

castInstance.Run(new DifferentParameter());

But your Implementation 's Run method can't take DifferentParameter !

.NET therefore prevents you from performing the cast itself.

There are situations in which this kind of cast is allowed - if your interface were instead to be defined as:

interface IInterface<out TOutput>
    where TOutput : IResult
{
    TOutput Run();
}

By making the generic parameter out , it makes the interface covariant . This restricts the use of the type parameter as the result of method calls, but for covariant interfaces, casts like yours are allowed.

You can find plenty of documentation on both covariance and contravariance in the .NET documentation .

Answer 2

Why don't you add a non-generic interface too:

interface IInterface { void Run(IParameter input); }

And then let your generic interface extend this non-generic one.

Obviously your implementations should cast the IParameter , someone needs to cast it... You could make an abstract base class that does this for you, so not every implementation has to do this.

You might also be interested in the double dispatch pattern, although I'm not sure this will work in your case.