C# 3.0 generic type inference – passing a delegate as a function parameter

by

Maybe this will make it clearer:

public class SomeClass
{
    static void foo(int x) { }
    static void foo(string s) { }
    static void bar<T>(Action<T> f){}
    static void barz(Action<int> f) { }
    static void test()
    {
        Action<int> f = foo;
        bar(f);
        barz(foo);
        bar(foo);
        //these help the compiler to know which types to use
        bar<int>(foo);
        bar( (int i) => foo(i));
    }
}

foo is not an action – foo is a method group.

  • In the assignment statement, the compiler can tell clearly which foo you’re talking about, since the int type is specified.
  • In the barz(foo) statement, the compiler can tell which foo you’re talking about, since the int type is specified.
  • In the bar(foo) statement, it could be any foo with a single parameter – so the compiler gives up.

Edit: I’ve added two (more) ways to help the compiler figure out the type (ie – how to skip the inference steps).

From my reading of the article in JSkeet’s answer, the decision to not infer the type seems to be based on a mutual infering scenario, such as

  static void foo<T>(T x) { }
  static void bar<T>(Action<T> f) { }
  static void test()
  {
    bar(foo); //wut's T?
  }

Since the general problem was unsolve-able, they choose to left specific problems where a solution exists as unsolved.

As a consequence of this decision, you won’t be adding a overload for a method and getting a whole lot of type confusion from all the callers that are used to a single member method group. I guess that’s a good thing.

More Related Contents:

  1. Why can’t the C# constructor infer type?
  2. Why must I provide explicitly generic parameter types While the compiler should infer the type?
  3. Partial generic type inference possible in C#?
  4. Why must a lambda expression be cast when supplied as a plain Delegate parameter
  5. C# Generics won’t allow Delegate Type Constraints
  6. Func delegate with ref variable
  7. List readonly with a private set
  8. Generics: Why can’t the compiler infer the type arguments in this case?
  9. Generic List as parameter on method
  10. Getting all types that implement an interface
  11. Unsubscribe anonymous method in C#
  12. Generics in C#, using type of a variable as parameter [duplicate]
  13. C# use System.Type as Generic parameter
  14. getting type T from IEnumerable
  15. What’s the hardest or most misunderstood aspect of LINQ? [closed]
  16. Delegates: Predicate vs. Action vs. Func
  17. Why isn’t ArrayList marked [Obsolete]?
  18. How do C# Events work behind the scenes?
  19. How to initialize a List to a given size (as opposed to capacity)?
  20. Why cannot IEnumerable be cast as IEnumerable?
  21. Can I specify a generic type in XAML (pre .NET 4 Framework)?
  22. Generic Type in constructor
  23. What is ‘1 in Collection type Name
  24. C# – static types cannot be used as type arguments
  25. Which C# method overload is chosen?
  26. Calling generic static method in PowerShell
  27. How do I create a delegate for a .NET property?
  28. Return a value from an Event — is there a Good Practice for this?
  29. Does Func.BeginInvoke use the ThreadPool?
  30. Is it good idea to use “Control.CheckForIllegalCrossThreadCalls = false” [duplicate]

Leave a Comment