C# Memoization des fonctions avec un nombre arbitraire d'arguments

D'abord, vous devez appeler sw.Reset() entre vos tests. Dans le cas contraire, vos résultats pour le second test seront en plus de au temps à partir du premier.

Deuxièmement, vous ne devriez probablement pas utiliser vals.GetHashCode() dans votre GetHashCode() override sur le compareur, car cela vous mènera à obtenir des codes de hachage différents pour les objets qui évalueraient à true pour votre Equals override. Pour l'instant, je m'inquiéterais de s'assurer que objets équivalents toujours obtenir le même code de hachage plutôt que d'essayer d'obtenir une distribution égale des codes. Si les codes de hachage ne correspondent pas, Equals ne sera jamais appelé, donc vous finirez par traiter les mêmes paramètres plusieurs fois.

Chronomètre.Stop ne réinitialise pas le chronomètre donc vous accumulez du temps à chaque démarrage/arrêt.

par exemple

  Stopwatch sw = new Stopwatch();

  sw.Start();
  System.Threading.Thread.Sleep(100);
  sw.Stop();
  Debug.WriteLine(sw.ElapsedTicks);

  sw.Start();
  System.Threading.Thread.Sleep(100);
  sw.Stop();
  Debug.WriteLine(sw.ElapsedTicks);

donne les résultats suivants""

228221
454626

Vous pouvez utiliser StopWatch.Restart (Framework 4.0) pour redémarrer le chronomètre à chaque fois, ou si pas de Framework 4.0, vous pouvez utiliser StopWatch.Reset pour réinitialiser le chronomètre.

Alternative (pour les tuples et les types anonymes) approche pourrait être comme suit:

static void Main(string[] args)
{
    var func = Memoize<int, int, int>(Func);

    Console.WriteLine(func(3)(4));
    Console.WriteLine(func(3)(5));
    Console.WriteLine(func(2)(5));
    Console.WriteLine(func(3)(4));
}

//lets pretend this is very-expensive-to-compute function
private static int Func(int i, int j)
{
    return i + j;
}

private static Func<TArg1, Func<TArg2, TRes>> Memoize<TArg1, TArg2, TRes>(Func<TArg1, TArg2, TRes> func)
{
     Func<TArg1, Func<TArg2, TRes>> func1 = 
        Memoize((TArg1 arg1) => Memoize((TArg2 arg2) => func(arg1, arg2)));

    return func1;
}

private static Func<TArg, TRes> Memoize<TArg, TRes>(Func<TArg, TRes> func)
{
    var cache = new Dictionary<TArg, TRes>();

    return arg =>
    {
        TRes res;

        if( !cache.TryGetValue(arg, out res) )
        {
            Console.WriteLine("Calculating " + arg.ToString());

            res = func(arg);

            cache.Add(arg, res);
        }
        else
        {
            Console.WriteLine("Getting from cache " + arg.ToString());
        }

        return res;
    };
}

basé sur ces deux fonctions Memoize vous pouvez facilement construire des extensions pour autant d'args que vous le souhaitez.

je suis d'abord venu ici à la recherche d'une méthode de mémoization abstraite pour une fonction sans paramètre. Ce n'est pas vraiment une réponse à la question mais je voulais partager ma solution au cas où quelqu'un d'autre viendrait chercher le cas simple.

public static class MemoizationExtensions
{
    public static Func<R> Memoize<R>(this Func<R> f)
    {
        bool hasBeenCalled = false; // Used to determine if we called the function and the result was the same as default(R)
        R returnVal = default(R);
        return () =>
        {
            // Should be faster than doing null checks and if we got a null the first time, 
            // we really want to memoize that result and not inadvertently call the function again.
            if (!hasBeenCalled)
            {
                hasBeenCalled = true;
                returnVal = f();
            }
            return returnVal;
        };
    }
}

si vous utilisez LinqPad vous pouvez utiliser le code suivant pour tester facilement la fonctionnalité en utilisant la méthode super cool Dump de LinqPad.

new List<Func<object>>(new Func<object>[] {
        () => { "Entered func A1".Dump(); return 1; },
        () => { "Entered func A2".Dump(); return default(int); },
        () => { "Entered func B1".Dump(); return String.Empty; },
        () => { "Entered func B2".Dump(); return default(string); },
        () => { "Entered func C1".Dump(); return new {Name = String.Empty}; },
        () => { "Entered func C2".Dump(); return null; },
    })
    .ForEach(f => {
        var f1 = MemoizationExtensions.Memoize(f);
        Enumerable
            .Range(1,3)
            .Select(i=>new {Run=i, Value=f1()})
            .Dump();
    });

Vous devrez inclure la classe Memoization extensions dans le code du script LinqPad sinon ça ne marchera pas!