I'm having lots of Funcy fun (fun intended) with generic methods. In most cases C# type inference is smart enough to find out what generic arguments it must use on my generic methods, but now I've got a design where the C# compiler doesn't succeed, while I believe it could have succeeded in finding the correct types.
Can anyone tell me whether the compiler is a bit dumb in this case, or is there a very clear reason why it can't infer my generic arguments?
Here's the code:
Classes and interface definitions:
interface IQuery<TResult> { }
interface IQueryProcessor
{
TResult Process<TQuery, TResult>(TQuery query)
where TQuery : IQuery<TResult>;
}
class SomeQuery : IQuery<string>
{
}
Some code that does not compile:
class Test
{
void Test(IQueryProcessor p)
{
var query = new SomeQuery();
// Does not compile :-(
p.Process(query);
// Must explicitly write all arguments
p.Process<SomeQuery, string>(query);
}
}
Why is this? What am I missing here?
Here's the compiler error message (it doesn't leave much to our imagination):
The type arguments for method IQueryProcessor.Process(TQuery) cannot be inferred from the usage. Try specifying the
type arguments explicitly.
The reason I believe C# should be able to infer it is because of the following:
- I supply an object that implements
IQuery<TResult>
.
- That only
IQuery<TResult>
version that type implements is IQuery<string>
and thus TResult must be string
.
- With this information the compiler has TResult and TQuery.
SOLUTION
For me the best solution was to change the IQueryProcessor
interface and use dynamic typing in the implementation:
public interface IQueryProcessor
{
TResult Process<TResult>(IQuery<TResult> query);
}
// Implementation
sealed class QueryProcessor : IQueryProcessor {
private readonly Container container;
public QueryProcessor(Container container) {
this.container = container;
}
public TResult Process<TResult>(IQuery<TResult> query) {
var handlerType =
typeof(IQueryHandler<,>).MakeGenericType(query.GetType(), typeof(TResult));
dynamic handler = container.GetInstance(handlerType);
return handler.Handle((dynamic)query);
}
}
The IQueryProcessor
interface now takes in a IQuery<TResult>
parameter. This way it can return a TResult
and this will solve the problems from the consumer's perspective. We need to use reflection in the implementation to get the actual implementation, since the concrete query types are needed (in my case). But here comes dynamic typing to the rescue which will do the reflection for us. You can read more about this in this article.
Question&Answers:
os 与恶龙缠斗过久,自身亦成为恶龙;凝视深渊过久,深渊将回以凝视…