How to implement a generic parameter that isn't generic
I have an interface with two generic parameters, but one of the parameters is expected to be provided by the class implementation.
public interface IA<T, U> { ... }
public class X<T> : IA<T, int> { ... }
public class Y<T> : IA<T, MyClass> { ... }
However, another interface have a method that takes an instance of IA
as a parameter - however, every instance must be the same (the same class can take multiples X
, but then it will never take a Y
, or vice-versa). I tried to put it as a generic constrainst, but then I have something like
public interface IB<T, U, V> where U : IA<T, V> {
void MyMethod(U value);
}
public class Z<T> : IB<T, X<T>, int> { ... }
Of course, I don't want to write that parameter V
, as I can't choose a value for it. The parameter U
already dictates what the value of V should be! However, I can't simply remove V
, because then I couldn't write the constraint.
Another solution is to not use the constraint:
public interface IB<T> {
void MyMethod(IA<T> value);
}
But this way, I can't ensure the implementation of IB
will receive only one implementation of IA
(ie. it will be able to receive both X
and Y
, and it should not).
Is there any way to avoid the creation of the generic parameter V
in the interface IB
(in the first solution) while still mutually-excluding the implementations of IA
? Is there any specific reason the compiler can't infer the type of V
and allow me to write only class Z<T> : IB<T, X<T>>
or this case just wasn't expected in the language specs/was chosen to not be implemented?
You already have enough generic types to restrict IB<T,U>.MyMethod()
from receiving both X
and Y
. You just need to define the method argument as accepting on a specific type.
public interface IA<T,U> {}
public class X<T> : IA<T,int> {}
public class Y<T> : IA<T,string> {}
public interface IB<T,U>
{
void MyMethod(IA<T,U> value);
}
IB<int,int> foo;
X<int> a;
Y<int> b;
foo.MyMethod(a); // will compile
foo.MyMethod(b); // will not compile
Is there any way to avoid the creation of the generic parameter V in the interface IB (in the first solution) while still mutually-excluding the implementations of IA? Is there any specific reason the compiler can't infer the type of V and allow me to write only class Z : IB> or this case just wasn't expected in the language specs/was chosen to not be implemented?
I don't think that's how inference works in C#. To infer the type for U
the MyMethod
would be written like this.
public interface IB<T>
{
void MyMethod<U>(IA<T,U> value);
}
IB<int> foo = null;
X<int> a;
foo.MyMethod(a); // int type is inferred by compiler
You still have to use IA<T,U>
in your IB
interface. I don't think there is an easy way around that.
上一篇: pip安装熊猫,不工作
下一篇: 如何实现不通用的通用参数