Ich möchte eine Erweiterungsmethode für eine Methode implementieren. Betrachten Sie das folgende Codebeispiel (http://dotnetfiddle.net/HztiOo):

using System;
using System.Collections.Generic;

public class Program
{
    public static void Main()
    {
        A a = new A();
        // Noticed that Next() is called twice
        Console.WriteLine(a.Next(1));
        Console.WriteLine(a.Next(1));

        // Works
        var withCache = ((Func<int,int>)a.Next).AddCaching();
        withCache = new Func<int,int>(a.Next).AddCaching();
        withCache = ExtensionMethods.AddCaching<int,int>(a.Next);

        // Doesn't work :(
        // withCache = a.Next.AddCaching<int,int>();
        // Func<int,int> withCache = a.Next.AddCaching();

        // Notice that Next() is only called once
        Console.WriteLine(withCache(1));
        Console.WriteLine(withCache(1));
    }
}

public class A
{
    public int Next(int n)
    {
        Console.WriteLine("Called Next("+n+")");
        return n + 1;
    }
}

public static class ExtensionMethods
{
    public static Func<TKey,TVal> AddCaching<TKey,TVal>(this Func&,lt;TKey,TVal> fetcher)
    {
        var cache = new Dictionary<TKey, TVal>();
        return k =>
        {
            if (!cache.ContainsKey(k)) cache[k] = fetcher(k);
            return cache[k];
        };
    }
}

Ich möchte die Erweiterungsmethode ohne explizite Besetzung aufrufen können. In den beiden obigen Beispielen "Funktioniert nicht" sollte das Typensystem in der Lage sein, die zu verwendende Überlastung selbst zu bestimmen ...

Warum kann ich nicht einfach verwendena.Next.AddCaching<int,int>() ?

Hinweis: Dies ist nur ein Beispiel. Ich bin nicht daran interessiert, die beste Methode zum Hinzufügen eines Caches zu einem Methodenaufruf zu erörtern, da es für diese Art von Erweiterungen viele andere Möglichkeiten gibt.