Cfrtjryk

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.

Here is my code:

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 the above 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 ... would be interesting to think of ways around this.

OK this is basically it. Note that this needs C# 7.3 .. also this is my first Code Review post so apologies if I broke any rules