Calculation caching experiment

Question

There are a lot of numerical properties to be invoked many times with an expensive calculation. Let’s say for the sake of example, they expose a Factorial:

public class Analysis
{
    public double n10 => F(10);
    public double n100 => F(100);
    double F(int n) => 
        n <= 1 ? 1 : n * F(n-1);
}

I was looking for a way to cache them while keeping syntax clean, so property calculation logic will not intermix with caching. A proposed solution is:

public class Analysis
{
    public double n10 => this.Cached() || F(10);
    public double n100 => this.Cached() || F(100);
    double F(int n) => 
        n <= 1 ? 1 : n * F(n-1);
}

Where library code is:

public static class Caching
{
    static ConditionalWeakTable<object, Dictionary<string, double>> Values { get; } =
        new ConditionalWeakTable<object, Dictionary<string, double>>();

    public static Value Cached(this object target, [CallerMemberName] string name = null) =>
        Values.GetOrCreateValue(target).ContainsKey(name) ?
            new Value(() => Values.GetOrCreateValue(target)[name], null) :
            new Value(null, v => Values.GetOrCreateValue(target)[name] = v);        
}

And:

public class Value
{
    public static implicit operator Value(double value) => new Value(() => value, null);
    public static implicit operator double(Value value) => value.Getter();
    public static bool operator true(Value value) => value.Getter != null;
    public static bool operator false(Value value) => value.Getter == null;

    public static Value operator |(Value cached, Value computed)
    {
        cached.Setter(computed);
        return computed;
    }

    public Value(Func<double> getter, Action<double> setter)
    {
        Getter = getter;
        Setter = setter;
    }

    Func<double> Getter { get; }
    Action<double> Setter { get; }
}

Answer 1

Operator-free version (answer to...your answer):

public static class Analysis
{
    public static readonly Lazy<double> n10 = new Lazy<double>(() => F(10));

    private double static F(int n)
    {
        return n <= 1 ? 1 : n * F(n - 1);
    }
}

Do not look at marginal style differences (I cannot get used/appreciate expression bodied functions but it's just my own problem), point I'd like to highlight is:

• You do not need Once class, Framework already has a class for lazy creation of values: Lazy<T>. It even nicely handle thread-safety issues (safe creation and/or publication) if field is not static (in that case C# itself helps us.)

Few minor notes about current code:

• Analysis class has no need to be instantiable and all methods can be static.
• Class itself can then be static.
• IMO you do not need a dictionary, first of all because of the performance impact (even if it's a concurrent collection without locks) but also because it limits its usage to static methods (you use MethodInfo as key).

I understand your point of view (C# syntax isn't so clean to be used for business logic) but instead of forcing syntax and change operators semantic I'd prefer to use another language. Boo was first that came to my mind (especially because to change and extend the language to have a DSL is incredibly easy). I used it few years ago then I'm not up-to-date with its evolution. There are also other tools (second thought if for Microsoft Modeling SDK if you like visual editors instead of plain text code)

Answer 2

@AdrianoRepetti Operator free version :)

public class Analysis
{
    public double n10 => (Once)(() => F(10));
    double F(int n) =>
        n <= 1 ? 1 : n * F(n - 1);
}

Where:

class Once
{
    static ConditionalWeakTable<object, ConcurrentDictionary<MethodInfo, double>> Values { get; } =
        new ConditionalWeakTable<object, ConcurrentDictionary<MethodInfo, double>>();

    public static implicit operator Once(Func<double> value) => new Once(value);
    public static implicit operator double(Once once) => once.Value;

    Once(Func<double> getter)
    {
        Getter = getter;            
    }

    double Value => Values.GetOrCreateValue(Getter.Target)
        .GetOrAdd(Getter.Method, _ => Getter());

    Func<double> Getter { get; }
}

As for me - it does not look so clean.

Answer 3

I find this a nice idea but not useful at all, sorry ;-)

You might as well create a decorator cache that stores the results.

A real cache should be able to cache expressions like:

var a = 2;
var b = 3;
CachedExpression.Calc(() => a * b);
CachedExpression.Calc(() => 2 * b);

where

class CachedExpression
{
    ...cache

    public static T Calc<T>(Expression<Func<T>> expr)
    {
        ...expression comparison magic, evaluation and caching
    }
}

but I doubt it will be faster then calculating the actual expression due to the C# Expression overhead.