fix whitespace + C#7-ify locking impls

Author: mythz

src/ServiceStack.Redis/RedisLock.cs

@@ -21,9 +21,9 @@ public RedisLock(RedisClient redisClient, string key, TimeSpan? timeOut)
                         //This pattern is taken from the redis command for SETNX http://redis.io/commands/setnx
 
                         //Calculate a unix time for when the lock should expire
-                        TimeSpan realSpan = timeOut ?? new TimeSpan(365, 0, 0, 0); //if nothing is passed in the timeout hold for a year
-                        DateTime expireTime = DateTime.UtcNow.Add(realSpan);
-                        string lockString = (expireTime.ToUnixTimeMs() + 1).ToString();
+                        var realSpan = timeOut ?? new TimeSpan(365, 0, 0, 0); //if nothing is passed in the timeout hold for a year
+                        var expireTime = DateTime.UtcNow.Add(realSpan);
+                        var lockString = (expireTime.ToUnixTimeMs() + 1).ToString();
 
                         //Try to set the lock, if it does not exist this will succeed and the lock is obtained
                         var nx = redisClient.SetValueIfNotExists(key, lockString);
@@ -35,9 +35,8 @@ public RedisLock(RedisClient redisClient, string key, TimeSpan? timeOut)
                         //Therefore we need to get the value of the lock to see when it should expire
 
                         redisClient.Watch(key);
-                        string lockExpireString = redisClient.Get<string>(key);
-                        long lockExpireTime;
-                        if (!long.TryParse(lockExpireString, out lockExpireTime))
+                        var lockExpireString = redisClient.Get<string>(key);
+                        if (!long.TryParse(lockExpireString, out var lockExpireTime))
                         {
                             redisClient.UnWatch();  // since the client is scoped externally
                             return false;

src/ServiceStack.Redis/Support/Locking/DisposableDistributedLock.cs

@@ -8,7 +8,6 @@ namespace ServiceStack.Redis.Support.Locking
     public class DisposableDistributedLock : IDisposable
     {
         private readonly IDistributedLock myLock;
-        private readonly long lockState;
         private readonly long lockExpire;
         private readonly IRedisClient myClient;
         private readonly string globalLockKey;
@@ -25,20 +24,12 @@ public DisposableDistributedLock(IRedisClient client, string globalLockKey, int
             myLock = new DistributedLock();
             myClient = client;
             this.globalLockKey = globalLockKey;
-            lockState = myLock.Lock(globalLockKey, acquisitionTimeout, lockTimeout, out lockExpire, myClient);
+            LockState = myLock.Lock(globalLockKey, acquisitionTimeout, lockTimeout, out lockExpire, myClient);
         }
 
+        public long LockState { get; }
 
-        public long LockState
-        {
-            get { return lockState; } 
-        }
-
-        public long LockExpire
-        {
-            get { return lockExpire; }
-        }
-
+        public long LockExpire => lockExpire;
 
         /// <summary>
         /// unlock

src/ServiceStack.Redis/Support/Locking/DistributedLock.cs

@@ -4,131 +4,127 @@
 namespace ServiceStack.Redis.Support.Locking
 {
     public class DistributedLock : IDistributedLock
-	{
+    {
         public const int LOCK_NOT_ACQUIRED = 0;
         public const int LOCK_ACQUIRED = 1;
         public const int LOCK_RECOVERED = 2;
 
-		/// <summary>
-		/// acquire distributed, non-reentrant lock on key
-		/// </summary>
-	    /// <param name="key">global key for this lock</param>
-		/// <param name="acquisitionTimeout">timeout for acquiring lock</param>
-		/// <param name="lockTimeout">timeout for lock, in seconds (stored as value against lock key) </param>
+        /// <summary>
+        /// acquire distributed, non-reentrant lock on key
+        /// </summary>
+        /// <param name="key">global key for this lock</param>
+        /// <param name="acquisitionTimeout">timeout for acquiring lock</param>
+        /// <param name="lockTimeout">timeout for lock, in seconds (stored as value against lock key) </param>
         /// <param name="client"></param>
         /// <param name="lockExpire"></param>
         public virtual long Lock(string key, int acquisitionTimeout, int lockTimeout, out long lockExpire, IRedisClient client)
-		{
-		    lockExpire = 0;
+        {
+            lockExpire = 0;
 
             // cannot lock on a null key
             if (key == null)
                 return LOCK_NOT_ACQUIRED;
 
-			const int sleepIfLockSet = 200;
-			acquisitionTimeout *= 1000; //convert to ms
-			int tryCount = (acquisitionTimeout / sleepIfLockSet) + 1;
+            const int sleepIfLockSet = 200;
+            acquisitionTimeout *= 1000; //convert to ms
+            int tryCount = (acquisitionTimeout / sleepIfLockSet) + 1;
 
-			var ts = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0));
-			var newLockExpire = CalculateLockExpire(ts, lockTimeout);
+            var ts = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0));
+            var newLockExpire = CalculateLockExpire(ts, lockTimeout);
 
             var localClient = (RedisClient)client;
             long wasSet = localClient.SetNX(key, BitConverter.GetBytes(newLockExpire));
-			int totalTime = 0;
+            int totalTime = 0;
             while (wasSet == LOCK_NOT_ACQUIRED && totalTime < acquisitionTimeout)
-			{
-				int count = 0;
-				while (wasSet == 0 && count < tryCount && totalTime < acquisitionTimeout)
-				{
-					TaskUtils.Sleep(sleepIfLockSet);
-					totalTime += sleepIfLockSet;					
-					ts = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0));
-					newLockExpire = CalculateLockExpire(ts, lockTimeout);
+            {
+                int count = 0;
+                while (wasSet == 0 && count < tryCount && totalTime < acquisitionTimeout)
+                {
+                    TaskUtils.Sleep(sleepIfLockSet);
+                    totalTime += sleepIfLockSet;
+                    ts = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0));
+                    newLockExpire = CalculateLockExpire(ts, lockTimeout);
                     wasSet = localClient.SetNX(key, BitConverter.GetBytes(newLockExpire));
-					count++;
-				}
-				// acquired lock!
+                    count++;
+                }
+                // acquired lock!
                 if (wasSet != LOCK_NOT_ACQUIRED) break;
 
-				// handle possibliity of crashed client still holding the lock
+                // handle possibliity of crashed client still holding the lock
                 using (var pipe = localClient.CreatePipeline())
-				{
-				    long lockValue=0;
-					pipe.QueueCommand(r => ((RedisNativeClient)r).Watch(key));
-					pipe.QueueCommand(r => ((RedisNativeClient)r).Get(key), x => lockValue = (x != null) ? BitConverter.ToInt64(x,0) : 0);
-					pipe.Flush();
+                {
+                    long lockValue = 0;
+                    pipe.QueueCommand(r => ((RedisNativeClient)r).Watch(key));
+                    pipe.QueueCommand(r => ((RedisNativeClient)r).Get(key), x => lockValue = (x != null) ? BitConverter.ToInt64(x, 0) : 0);
+                    pipe.Flush();
 
-					// if lock value is 0 (key is empty), or expired, then we can try to acquire it
+                    // if lock value is 0 (key is empty), or expired, then we can try to acquire it
                     ts = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0));
-					if (lockValue < ts.TotalSeconds)
-					{
-						ts = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0));
-						newLockExpire = CalculateLockExpire(ts, lockTimeout);
-						using (var trans = localClient.CreateTransaction())
-						{
-							var expire = newLockExpire;
-							trans.QueueCommand(r => ((RedisNativeClient)r).Set(key, BitConverter.GetBytes(expire)));
-							if (trans.Commit())
-								wasSet = LOCK_RECOVERED; //recovered lock!
-						}
-					}
-					else
-					{
+                    if (lockValue < ts.TotalSeconds)
+                    {
+                        ts = (DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0));
+                        newLockExpire = CalculateLockExpire(ts, lockTimeout);
+                        using (var trans = localClient.CreateTransaction())
+                        {
+                            var expire = newLockExpire;
+                            trans.QueueCommand(r => ((RedisNativeClient)r).Set(key, BitConverter.GetBytes(expire)));
+                            if (trans.Commit())
+                                wasSet = LOCK_RECOVERED; //recovered lock!
+                        }
+                    }
+                    else
+                    {
                         localClient.UnWatch();
-					}
-				}
+                    }
+                }
                 if (wasSet != LOCK_NOT_ACQUIRED) break;
-				TaskUtils.Sleep(sleepIfLockSet);
-				totalTime += sleepIfLockSet;
-			}
+                TaskUtils.Sleep(sleepIfLockSet);
+                totalTime += sleepIfLockSet;
+            }
             if (wasSet != LOCK_NOT_ACQUIRED)
             {
                 lockExpire = newLockExpire;
             }
-		    return wasSet;
-
-		}
+            return wasSet;
+        }
 
-  
-		/// <summary>
-		/// unlock key
-		/// </summary>
-		public virtual bool Unlock(string key, long lockExpire, IRedisClient client)
-		{
-			if (lockExpire <= 0)
-				return false;
-		    long lockVal = 0;
+        /// <summary>
+        /// unlock key
+        /// </summary>
+        public virtual bool Unlock(string key, long lockExpire, IRedisClient client)
+        {
+            if (lockExpire <= 0)
+                return false;
+            long lockVal = 0;
             var localClient = (RedisClient)client;
             using (var pipe = localClient.CreatePipeline())
             {
-               
-                pipe.QueueCommand(r => ((RedisNativeClient) r).Watch(key));
-                pipe.QueueCommand(r => ((RedisNativeClient) r).Get(key),
+
+                pipe.QueueCommand(r => ((RedisNativeClient)r).Watch(key));
+                pipe.QueueCommand(r => ((RedisNativeClient)r).Get(key),
                                   x => lockVal = (x != null) ? BitConverter.ToInt64(x, 0) : 0);
                 pipe.Flush();
             }
 
-		    if (lockVal != lockExpire)
-		    {
+            if (lockVal != lockExpire)
+            {
                 if (lockVal != 0)
-                    Debug.WriteLine(String.Format("Unlock(): Failed to unlock key {0}; lock has been acquired by another client ", key));
+                    Debug.WriteLine($"Unlock(): Failed to unlock key {key}; lock has been acquired by another client ");
                 else
-                    Debug.WriteLine(String.Format("Unlock(): Failed to unlock key {0}; lock has been identifed as a zombie and harvested ", key));
+                    Debug.WriteLine($"Unlock(): Failed to unlock key {key}; lock has been identifed as a zombie and harvested ");
                 localClient.UnWatch();
-		        return false;
-		    }
+                return false;
+            }
 
             using (var trans = localClient.CreateTransaction())
             {
                 trans.QueueCommand(r => ((RedisNativeClient)r).Del(key));
-                var rc =  trans.Commit();
+                var rc = trans.Commit();
                 if (!rc)
-                    Debug.WriteLine(String.Format("Unlock(): Failed to delete key {0}; lock has been acquired by another client ", key));
+                    Debug.WriteLine($"Unlock(): Failed to delete key {key}; lock has been acquired by another client ");
                 return rc;
             }
-
-		}
-
+        }
 
         /// <summary>
         /// 
@@ -140,6 +136,5 @@ private static long CalculateLockExpire(TimeSpan ts, int timeout)
         {
             return (long)(ts.TotalSeconds + timeout + 1.5);
         }
-
-	}
+    }
 }

src/ServiceStack.Redis/Support/Locking/IDistributedLock.cs

@@ -4,8 +4,8 @@
     /// Distributed lock interface
     /// </summary>
 	public interface IDistributedLock
-	{
-	    long Lock(string key, int acquisitionTimeout, int lockTimeout, out long lockExpire, IRedisClient client);
-	    bool Unlock(string key, long lockExpire, IRedisClient client);
-	}
+    {
+        long Lock(string key, int acquisitionTimeout, int lockTimeout, out long lockExpire, IRedisClient client);
+        bool Unlock(string key, long lockExpire, IRedisClient client);
+    }
 }

src/ServiceStack.Redis/Support/Locking/ILockingStrategy.cs

@@ -6,9 +6,9 @@ namespace ServiceStack.Redis.Support.Locking
     /// Locking strategy interface
     /// </summary>
 	public interface ILockingStrategy
-	{
-		IDisposable ReadLock();
+    {
+        IDisposable ReadLock();
 
-		IDisposable WriteLock();
-	}
+        IDisposable WriteLock();
+    }
 }

src/ServiceStack.Redis/Support/Locking/NoLockingStrategy.cs

@@ -2,16 +2,16 @@
 
 namespace ServiceStack.Redis.Support.Locking
 {
-	public class NoLockingStrategy : ILockingStrategy
-	{
-		public IDisposable ReadLock()
-		{
-			return null;
-		}
+    public class NoLockingStrategy : ILockingStrategy
+    {
+        public IDisposable ReadLock()
+        {
+            return null;
+        }
 
-		public IDisposable WriteLock()
-		{
-			return null;
-		}
-	}
+        public IDisposable WriteLock()
+        {
+            return null;
+        }
+    }
 }

src/ServiceStack.Redis/Support/Locking/ReadLock.cs

@@ -3,30 +3,30 @@
 
 namespace ServiceStack.Redis.Support.Locking
 {
-	/// <summary>
-	/// This class manages a read lock for a local readers/writer lock, 
-	/// using the Resource Acquisition Is Initialization pattern
-	/// </summary>
-	public class ReadLock : IDisposable
-	{
-		private readonly ReaderWriterLockSlim lockObject;
+    /// <summary>
+    /// This class manages a read lock for a local readers/writer lock, 
+    /// using the Resource Acquisition Is Initialization pattern
+    /// </summary>
+    public class ReadLock : IDisposable
+    {
+        private readonly ReaderWriterLockSlim lockObject;
 
-		/// <summary>
-		/// RAII initialization 
-		/// </summary>
-		/// <param name="lockObject"></param>
-		public ReadLock(ReaderWriterLockSlim lockObject)
-		{
-			this.lockObject = lockObject;
-			lockObject.EnterReadLock();
-		}
+        /// <summary>
+        /// RAII initialization 
+        /// </summary>
+        /// <param name="lockObject"></param>
+        public ReadLock(ReaderWriterLockSlim lockObject)
+        {
+            this.lockObject = lockObject;
+            lockObject.EnterReadLock();
+        }
 
-		/// <summary>
-		/// RAII disposal
-		/// </summary>
-		public void Dispose()
-		{
-			lockObject.ExitReadLock();
-		}
-	}
+        /// <summary>
+        /// RAII disposal
+        /// </summary>
+        public void Dispose()
+        {
+            lockObject.ExitReadLock();
+        }
+    }
 }