Nsryjdtyk

I've been working for a while on locking resources (state objects) so that the only way to access them is by acquiring a lock, I wanted something with a lot of syntactic sugar so that once the lock is acquired the resource (object) is used via a reference without a need for special getters and setters.

namespace Lockable {

  public delegate void ActionRef<REF>(ref REF r1);

  public delegate void ActionIn<REF>(in REF r1);

  public delegate RES FuncRef<REF, RES>(ref REF r1);

  public delegate RES FuncIn<REF, RES>(in REF r1);

  public delegate void ActionRef<REF1, REF2>(ref REF1 r1, ref REF2 r2);

  public delegate void ActionIn<REF1, REF2>(in REF1 r1, in REF2 r2);

  public delegate RES FuncRef<REF1, REF2, RES>(ref REF1 r1, ref REF2 r2);

  public delegate RES FuncIn<REF1, REF2, RES>(in REF1 r1, in REF2 r2);

  public delegate void ActionRef<REF1, REF2, REF3>(ref REF1 r1, ref REF2 r2, ref REF3 r3);

  public delegate void ActionIn<REF1, REF2, REF3>(in REF1 r1, in REF2 r2, in REF3 r3);

  public delegate RES FuncRef<REF1, REF2, REF3, RES>(ref REF1 r1, ref REF2 r2, ref REF3 r3);

  public delegate RES FuncIn<REF1, REF2, REF3, RES>(in REF1 r1, in REF2 r2, in REF3 r3);



  public class Lockable<T> {

    public Lockable() { }

    public Lockable(T val) => this.val = val;

    readonly object theLock = new object();

    T val;



    public void Lock(ActionRef<T> f) { lock (theLock) f(ref val); }

    public void Lock(ActionIn<T> f) { lock (theLock) f(in val); }

    public TRES Lock<TRES>(FuncRef<T, TRES> f) { lock (theLock) return f(ref val); }

    public TRES Lock<TRES>(FuncIn<T, TRES> f) { lock (theLock) return f(in val); }



    public class TwoLockable<T2> {

      public TwoLockable(Lockable<T> val1, Lockable<T2> val2) { this.l1 = val1; this.l2 = val2; }

      readonly Lockable<T> l1; readonly Lockable<T2> l2;



      public void Lock(ActionRef<T, T2> f) { lock (l1.theLock) lock (l2.theLock) f(ref l1.val, ref l2.val); }

      public void Lock(ActionIn<T, T2> f) { lock (l1.theLock) lock (l2.theLock) f(in l1.val, in l2.val); }

      public TRES Lock<TRES>(FuncRef<T, T2, TRES> f) { lock (l1.theLock) lock (l2.theLock) return f(ref l1.val, ref l2.val); }

      public TRES Lock<TRES>(FuncIn<T, T2, TRES> f) { lock (l1.theLock) lock (l2.theLock) return f(in l1.val, in l2.val); }



      public class ThreeLockable<T3> {

        public ThreeLockable(Lockable<T> val1, Lockable<T2> val2, Lockable<T3> val3) { this.l1 = val1; this.l2 = val2; this.l3 = val3; }

        readonly Lockable<T> l1; readonly Lockable<T2> l2; readonly Lockable<T3> l3;



        public void Lock(ActionRef<T, T2, T3> f) { lock (l1.theLock) lock (l2.theLock) lock (l3.theLock) f(ref l1.val, ref l2.val, ref l3.val); }

        public void Lock(ActionIn<T, T2, T3> f) { lock (l1.theLock) lock (l2.theLock) lock (l3.theLock) f(in l1.val, in l2.val, in l3.val); }

        public TRES Lock<TRES>(FuncRef<T, T2, T3, TRES> f) { lock (l1.theLock) lock (l2.theLock) lock (l3.theLock) return f(ref l1.val, ref l2.val, ref l3.val); }

        public TRES Lock<TRES>(FuncIn<T, T2, T3, TRES> f) { lock (l1.theLock) lock (l2.theLock) lock (l3.theLock) return f(in l1.val, in l2.val, in l3.val); }

      }

      public ThreeLockable<T3> Combine<T3>(Lockable<T3> l3) => new ThreeLockable<T3>(this.l1, this.l2, l3);

    }

    public TwoLockable<T2> Combine<T2>(Lockable<T2> l2) => new TwoLockable<T2>(this, l2);

  }

}

With that code, I can now do this:

class State {

    public readonly Lockable<Customers> Customers = new Lockable<Customers>(new Customers());

    public readonly Lockable<Agents> Agents = new Lockable<Agents>(new Agents());

}

and then:

var S = new State(); // usually this will be a static/singleton

now the only way to access Customers is via the Lock method like this:

S.Customers.Lock((ref Customers Customers) => {

    Log(Customers.GetPhone("John"));

    Customers=new Customers();

    Customers.Add("Mary");

});

or to return a value I can do:

var count = S.Customers.Lock((ref Customers Customers) => Customers.Count());

Note that you can use the above to modify the state without locking i.e.:

var UnlockedCustomers = S.Customers.Lock((ref Customers Customers) => Customers);

UnlockedCustomers.Add("Dave"); // unlocked !!!

This is by design as I wanted to allow that but make it very explicit in the code (unlike forgetting to lock..), if this is not desired the locks returning values need to be removed (FuncRefs etc.).

If I need to lock both I combine the Locks:

S.Customers.Combine(S.Agents).Lock((ref Customers Customers, ref Agents Agents) => {

  // both Agents and Customers are locked here !

});

I included versions of combining 2 and 3 Lockables. More can be added. Note that as with locks you have to always combine in the same order or risk deadlocks. It would be interesting to think of ways around this.

Welcome to maintanance-hell

The code in question is unreadable and un-reviewable. Stuffing that much code in single-lines is just horrible.

Before Sam the maintainer would try to fix a bug or add some new functionality to this code Sam would invent a time-travelling-machine to travel back in time and would have some serious talk with you which could get physical.

Code should be written in such a way that it is as easiest as possible, for Sam the maintainer or anybody who reads the code, to grasp at first glance what the code is about.