7

Let's say I have a service interface that looks like this:

public interface IFooService
{
    FooResponse Foo(FooRequest request);
}

I would like to fulfill some cross-cutting concerns when calling methods on services like these; for example, I want unified request logging, performance logging, and error handling. My approach is to have a common base "Repository' class with an Invoke method that takes care of invoking the method and doing other things around it. My base class looks something like this:

public class RepositoryBase<TService>
{
    private Func<TService> serviceFactory;

    public RepositoryBase(Func<TService> serviceFactory)
    {
        this.serviceFactory = serviceFactory;
    }

    public TResponse Invoke<TRequest, TResponse>(
        Func<TService, Func<TRequest, TResponse>> methodExpr,
        TRequest request)
    {
        // Do cross-cutting code

        var service = this.serviceFactory();
        var method = methodExpr(service);
        return method(request);
    }
}

This works fine. However, my whole goal of making the code cleaner is thwarted by the fact that type inference isn't working as expected. For example, if I write a method like this:

public class FooRepository : BaseRepository<IFooService>
{
    // ...

    public BarResponse CallFoo(...)
    {
        FooRequest request = ...;
        var response = this.Invoke(svc => svc.Foo, request);
        return response;
    }
}

I get this compilation error:

The type arguments for method ... cannot be inferred from the usage. Try specifying the type arguments explicitly.

Obviously, I can fix it by changing my call to:

var response = this.Invoke<FooRequest, FooResponse>(svc => svc.Foo, request);

But I'd like to avoid this. Is there a way to rework the code so that I can take advantage of type inference?

Edit:

I should also mention that an earlier approach was to use an extension method; type inference for this worked:

public static class ServiceExtensions
{
    public static TResponse Invoke<TRequest, TResponse>(
        this IService service, 
        Func<TRequest, TResponse> method, 
        TRequest request)
    {
        // Do other stuff
        return method(request);
    }
}

public class Foo
{
    public void SomeMethod()
    {
        IService svc = ...;
        FooRequest request = ...;
        svc.Invoke(svc.Foo, request);
    }
}
Improve this question

3 Answers 3

Reset to default
13

The question which is the title of your question is "why isn't type inference working in this code?" Let's simply the code in question. The scenario is at its heart:

class Bar { }

interface I
{
    int Foo(Bar bar);
}

class C
{
    public static R M<A, R>(A a, Func<I, Func<A, R>> f) 
    { 
        return default(R); 
    }
}

The call site is

C.M(new Bar(), s => s.Foo);

We must determine two facts: what are A and R? What information do we have to go on? That new Bar() corresponds to A and s=>s.Foo corresponds to Func<I, Func<A, R>>.

Clearly we can determine that A must be Bar from that first fact. And clearly we can determine that s must be I. So we now know that (I s)=>s.Foo corresponds to Func<I, Func<Bar, R>>.

Now the question is: can we infer that R is int by doing overload resolution on s.Foo in the body of the lambda?

Sadly, the answer is no. You and I can do that inference, but the compiler does not. When we designed the type inference algorithm we considered adding this kind of "multi-level" lambda/delegate/method group inference but decided that it was too high cost for the benefit it would confer.

Sorry, you are out of luck here; in general, inferences that would require "digging through" more than one level of functional abstraction are not made in C# method type inference.

Why did this work when using extension methods, then?

Because the extension method does not have more than one level of functional abstraction. The extension method case is:

class C
{
    public static R M<A, R>(I i, A a, Func<A, R> f) { ... }
}

with a call site

I i = whatever;
C.M(i, new Bar(), i.Foo);

Now what information do we have? We deduce that A is Bar as before. Now we must deduce what R is knowing that i.Foo maps to Func<Bar, R>. This is a straightforward overload resolution problem; we pretend that there was a call to i.Foo(Bar) and let overload resolution do its work. Overload resolution comes back and says that i.Foo(Bar) returns int, so R is int.

Note that this kind of inference -- involving a method group -- was intended to be added to C# 3 but I messed up and we did not get it done in time. We ended up adding that kind of inference to C# 4.

Note also that for this kind of inference to succeed, all the parameter types must already be inferred. We must be inferring only the return type, because in order to know the return type, we must be able to do overload resolution, and to do overload resolution, we must know all the parameter types. We do not do any nonsense like "oh, the method group only has one method in it, so let's skip doing overload resolution and just let that method win automatically".

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

0

Why not simply invoke the method directly? IE:

public class ClassBase<TService>
{
     protected Func<TService> _serviceFactory = null;

     public ClassBase(Func<TService> serviceFactory)
     {
         _serviceFactory = serviceFactory;
     }

     public virtual TResponse Invoke<TResponse>(Func<TService, TResponse> valueFactory)
     {
          // Do Stuff

          TService service = serviceFactory();
          return valueFactory(service);
     }
}

Then you should theoretically be able to do this:

public class Sample : ClassBase<SomeService>
{
     public Bar CallFoo()
     {
          FooRequest request = ...
          var response = Invoke(svc => svc.Foo(request));
          return new Bar(response);
     }
}
Improve this answer

6 Comments

The reason why I want to pass the request object as an argument is so that the request can be serialized and logged. I could do both, call the method directly and pass the request object, but I want to avoid this redundancy.
You could always make the Func into an Expression<Func> and then inspect the expression for serialization.
Yes, that's an option, but I would prefer to avoid the performance hit of using reflection.
The problem is going to be dealing with method groups if you decide to go with the parameter less method name. If you added an overload of Foo to your service, which one would be chosen? The return type would not be known ahead of time.
Plus, if you really need to deal with the request item by itself, it seems you would be better served to simply make another method and call that before calling Invoke to serialize and store whatever you need.
|
0

After your last edit, we see that svc.Foo is a method group; that explains the type inference failure. The compiler needs to know the type arguments so it can pick the correct Foo overload for the method group conversion.

Improve this answer

2 Comments

I'll add the IFooService interface to my question; it is a method that is compatible with Func<TRequest, TResponse>.
@Jacob The compiler can't infer the types for a method group conversion because it needs to know the types in order to select the correct overload of Foo. Here you have only one overload, of course, but the need to solve the general problem explains the failure of type inference in this case.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.