diff --git a/cs/src/core/ClientSession/BasicContext.cs b/cs/src/core/ClientSession/BasicContext.cs
new file mode 100644
index 000000000..7e496af18
--- /dev/null
+++ b/cs/src/core/ClientSession/BasicContext.cs
@@ -0,0 +1,228 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using System.Diagnostics;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace FASTER.core
+{
+    /// <summary>
+    /// Basic Faster Context implementation.
+    /// </summary>
+    public readonly struct BasicContext<Key, Value, Input, Output, Context, Functions> : IFasterContext<Key, Value, Input, Output, Context>
+        where Functions : IFunctions<Key, Value, Input, Output, Context>
+    {
+        readonly ClientSession<Key, Value, Input, Output, Context, Functions> clientSession;
+
+        internal BasicContext(ClientSession<Key, Value, Input, Output, Context, Functions> clientSession)
+        {
+            this.clientSession = clientSession;
+        }
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UnsafeResumeThread()
+            => clientSession.UnsafeResumeThread();
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UnsafeResumeThread(out int resumeEpoch)
+            => clientSession.UnsafeResumeThread(out resumeEpoch);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UnsafeSuspendThread()
+            => clientSession.UnsafeSuspendThread();
+
+        #region IFasterContext
+
+        /// <inheritdoc/>
+        public bool CompletePending(bool wait = false, bool spinWaitForCommit = false)
+            => clientSession.CompletePending(wait, spinWaitForCommit);
+
+        /// <inheritdoc/>
+        public bool CompletePendingWithOutputs(out CompletedOutputIterator<Key, Value, Input, Output, Context> completedOutputs, bool wait = false, bool spinWaitForCommit = false)
+            => clientSession.CompletePendingWithOutputs(out completedOutputs, wait, spinWaitForCommit);
+
+        /// <inheritdoc/>
+        public ValueTask CompletePendingAsync(bool waitForCommit = false, CancellationToken token = default)
+            => clientSession.CompletePendingAsync(waitForCommit, token);
+
+        /// <inheritdoc/>
+        public ValueTask<CompletedOutputIterator<Key, Value, Input, Output, Context>> CompletePendingWithOutputsAsync(bool waitForCommit = false, CancellationToken token = default)
+            => clientSession.CompletePendingWithOutputsAsync(waitForCommit, token);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Status Read(ref Key key, ref Input input, ref Output output, Context userContext = default, long serialNo = 0)
+            => clientSession.Read(ref key, ref input, ref output, userContext, serialNo);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Status Read(Key key, Input input, out Output output, Context userContext = default, long serialNo = 0)
+            => clientSession.Read(key, input, out output, userContext, serialNo);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Status Read(ref Key key, ref Output output, Context userContext = default, long serialNo = 0)
+            => clientSession.Read(ref key, ref output, userContext, serialNo);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Status Read(Key key, out Output output, Context userContext = default, long serialNo = 0)
+            => clientSession.Read(key, out output, userContext, serialNo);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public (Status status, Output output) Read(Key key, Context userContext = default, long serialNo = 0)
+            => clientSession.Read(key, userContext, serialNo);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Status Read(ref Key key, ref Input input, ref Output output, ref ReadOptions readOptions, out RecordMetadata recordMetadata, Context userContext = default, long serialNo = 0)
+            => clientSession.Read(ref key, ref input, ref output, ref readOptions, out recordMetadata, userContext, serialNo);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Status ReadAtAddress(ref Input input, ref Output output, ref ReadOptions readOptions, Context userContext = default, long serialNo = 0)
+            => clientSession.ReadAtAddress(ref input, ref output, ref readOptions, userContext, serialNo);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ValueTask<FasterKV<Key, Value>.ReadAsyncResult<Input, Output, Context>> ReadAsync(ref Key key, ref Input input, Context userContext = default, long serialNo = 0, CancellationToken cancellationToken = default)
+            => clientSession.ReadAsync(ref key, ref input, userContext, serialNo, cancellationToken);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ValueTask<FasterKV<Key, Value>.ReadAsyncResult<Input, Output, Context>> ReadAsync(Key key, Input input, Context context = default, long serialNo = 0, CancellationToken token = default)
+            => clientSession.ReadAsync(key, input, context, serialNo, token);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ValueTask<FasterKV<Key, Value>.ReadAsyncResult<Input, Output, Context>> ReadAsync(ref Key key, Context userContext = default, long serialNo = 0, CancellationToken token = default)
+            => clientSession.ReadAsync(ref key, userContext, serialNo, token);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ValueTask<FasterKV<Key, Value>.ReadAsyncResult<Input, Output, Context>> ReadAsync(Key key, Context context = default, long serialNo = 0, CancellationToken token = default)
+            => clientSession.ReadAsync(key, context, serialNo, token);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ValueTask<FasterKV<Key, Value>.ReadAsyncResult<Input, Output, Context>> ReadAsync(ref Key key, ref Input input, ref ReadOptions readOptions, Context userContext = default, long serialNo = 0, CancellationToken cancellationToken = default)
+            => clientSession.ReadAsync(ref key, ref input, ref readOptions, userContext, serialNo, cancellationToken);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ValueTask<FasterKV<Key, Value>.ReadAsyncResult<Input, Output, Context>> ReadAtAddressAsync(ref Input input, ref ReadOptions readOptions, Context userContext = default, long serialNo = 0, CancellationToken cancellationToken = default)
+            => clientSession.ReadAtAddressAsync(ref input, ref readOptions, userContext, serialNo, cancellationToken);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Status Upsert(ref Key key, ref Value desiredValue, Context userContext = default, long serialNo = 0)
+            => clientSession.Upsert(ref key, ref desiredValue, userContext, serialNo);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Status Upsert(ref Key key, ref Input input, ref Value desiredValue, ref Output output, Context userContext = default, long serialNo = 0)
+            => clientSession.Upsert(ref key, ref input, ref desiredValue, ref output, userContext, serialNo);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Status Upsert(ref Key key, ref Input input, ref Value desiredValue, ref Output output, out RecordMetadata recordMetadata, Context userContext = default, long serialNo = 0)
+            => clientSession.Upsert(ref key, ref input, ref desiredValue, ref output, out recordMetadata, userContext, serialNo);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Status Upsert(Key key, Value desiredValue, Context userContext = default, long serialNo = 0)
+            => clientSession.Upsert(key, desiredValue, userContext, serialNo);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Status Upsert(Key key, Input input, Value desiredValue, ref Output output, Context userContext = default, long serialNo = 0)
+            => clientSession.Upsert(key, input, desiredValue, ref output, userContext, serialNo);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ValueTask<FasterKV<Key, Value>.UpsertAsyncResult<Input, Output, Context>> UpsertAsync(ref Key key, ref Value desiredValue, Context userContext = default, long serialNo = 0, CancellationToken token = default)
+            => clientSession.UpsertAsync(ref key, ref desiredValue, userContext, serialNo, token);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ValueTask<FasterKV<Key, Value>.UpsertAsyncResult<Input, Output, Context>> UpsertAsync(ref Key key, ref Input input, ref Value desiredValue, Context userContext = default, long serialNo = 0, CancellationToken token = default)
+            => clientSession.UpsertAsync(ref key, ref input, ref desiredValue, userContext, serialNo, token);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ValueTask<FasterKV<Key, Value>.UpsertAsyncResult<Input, Output, Context>> UpsertAsync(Key key, Value desiredValue, Context userContext = default, long serialNo = 0, CancellationToken token = default)
+            => clientSession.UpsertAsync(key, desiredValue, userContext, serialNo, token);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ValueTask<FasterKV<Key, Value>.UpsertAsyncResult<Input, Output, Context>> UpsertAsync(Key key, Input input, Value desiredValue, Context userContext = default, long serialNo = 0, CancellationToken token = default)
+            => clientSession.UpsertAsync(key, input, desiredValue, userContext, serialNo, token);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Status RMW(ref Key key, ref Input input, ref Output output, Context userContext = default, long serialNo = 0)
+            => clientSession.RMW(ref key, ref input, ref output, userContext, serialNo);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Status RMW(ref Key key, ref Input input, ref Output output, out RecordMetadata recordMetadata, Context userContext = default, long serialNo = 0)
+            => clientSession.RMW(ref key, ref input, ref output, out recordMetadata, userContext, serialNo);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Status RMW(Key key, Input input, out Output output, Context userContext = default, long serialNo = 0)
+            => clientSession.RMW(key, input, out output, userContext, serialNo);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Status RMW(ref Key key, ref Input input, Context userContext = default, long serialNo = 0)
+            => clientSession.RMW(ref key, ref input, userContext, serialNo);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Status RMW(Key key, Input input, Context userContext = default, long serialNo = 0)
+            => clientSession.RMW(key, input, userContext, serialNo);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ValueTask<FasterKV<Key, Value>.RmwAsyncResult<Input, Output, Context>> RMWAsync(ref Key key, ref Input input, Context context = default, long serialNo = 0, CancellationToken token = default)
+            => clientSession.RMWAsync(ref key, ref input, context, serialNo, token);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ValueTask<FasterKV<Key, Value>.RmwAsyncResult<Input, Output, Context>> RMWAsync(Key key, Input input, Context context = default, long serialNo = 0, CancellationToken token = default)
+            => clientSession.RMWAsync(key, input, context, serialNo, token);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Status Delete(ref Key key, Context userContext = default, long serialNo = 0)
+            => clientSession.Delete(ref key, userContext, serialNo);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Status Delete(Key key, Context userContext = default, long serialNo = 0)
+            => clientSession.Delete(key, userContext, serialNo);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ValueTask<FasterKV<Key, Value>.DeleteAsyncResult<Input, Output, Context>> DeleteAsync(ref Key key, Context userContext = default, long serialNo = 0, CancellationToken token = default)
+            => clientSession.DeleteAsync(ref key, userContext, serialNo, token);
+
+        /// <inheritdoc/>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public ValueTask<FasterKV<Key, Value>.DeleteAsyncResult<Input, Output, Context>> DeleteAsync(Key key, Context userContext = default, long serialNo = 0, CancellationToken token = default)
+            => clientSession.DeleteAsync(key, userContext, serialNo, token);
+
+        /// <inheritdoc/>
+        public void Refresh()
+            => clientSession.Refresh();
+
+        #endregion IFasterContext
+    }
+}
diff --git a/cs/src/core/ClientSession/ClientSession.cs b/cs/src/core/ClientSession/ClientSession.cs
index 4b79664e6..b117954c7 100644
--- a/cs/src/core/ClientSession/ClientSession.cs
+++ b/cs/src/core/ClientSession/ClientSession.cs
@@ -37,13 +37,51 @@ public sealed class ClientSession<Key, Value, Input, Output, Context, Functions>
 
         UnsafeContext<Key, Value, Input, Output, Context, Functions> uContext;
         LockableUnsafeContext<Key, Value, Input, Output, Context, Functions> luContext;
-        LockableContext<Key, Value, Input, Output, Context, Functions> lContext;
+        readonly LockableContext<Key, Value, Input, Output, Context, Functions> lContext;
+        readonly BasicContext<Key, Value, Input, Output, Context, Functions> bContext;
 
         internal const string NotAsyncSessionErr = "Session does not support async operations";
 
         readonly ILoggerFactory loggerFactory;
         readonly ILogger logger;
 
+        internal ulong TotalLockCount => sharedLockCount + exclusiveLockCount;
+        internal ulong sharedLockCount;
+        internal ulong exclusiveLockCount;
+
+        bool isAcquired;
+
+        internal void Acquire()
+        {
+            CheckNotAcquired();
+            fht.IncrementNumLockingSessions();
+            isAcquired = true;
+        }
+
+        internal void Release()
+        {
+            CheckAcquired();
+            isAcquired = false;
+            fht.DecrementNumLockingSessions();
+        }
+
+        internal void CheckAcquired()
+        {
+            if (!isAcquired)
+                throw new FasterException("Method call on not-acquired Context");
+        }
+
+        void CheckNotAcquired()
+        {
+            if (isAcquired)
+                throw new FasterException("Method call on acquired Context");
+        }
+
+        /// <summary>
+        /// Local current epoch
+        /// </summary>
+        public int LocalCurrentEpoch => fht.epoch.LocalCurrentEpoch;
+
         internal ClientSession(
             FasterKV<Key, Value> fht,
             FasterKV<Key, Value>.FasterExecutionContext<Input, Output, Context> ctx,
@@ -51,8 +89,11 @@ internal ClientSession(
             SessionVariableLengthStructSettings<Value, Input> sessionVariableLengthStructSettings,
             ILoggerFactory loggerFactory = null)
         {
+            this.lContext = new(this);
+            this.bContext = new(this);
+
             this.loggerFactory = loggerFactory;
-            this.logger = loggerFactory?.CreateLogger($"ClientSession-{GetHashCode().ToString("X8")}");
+            this.logger = loggerFactory?.CreateLogger($"ClientSession-{GetHashCode():X8}");
             this.fht = fht;
             this.ctx = ctx;
             this.functions = functions;
@@ -72,7 +113,7 @@ internal ClientSession(
             }
             else
             {
-                if (!(fht.hlog is VariableLengthBlittableAllocator<Key, Value>))
+                if (fht.hlog is not VariableLengthBlittableAllocator<Key, Value>)
                     logger?.LogWarning("Warning: Session param of variableLengthStruct provided for non-varlen allocator");
             }
 
@@ -101,7 +142,7 @@ internal ClientSession(
 
         private void UpdateVarlen(ref IVariableLengthStruct<Value, Input> variableLengthStruct)
         {
-            if (!(fht.hlog is VariableLengthBlittableAllocator<Key, Value>))
+            if (fht.hlog is not VariableLengthBlittableAllocator<Key, Value>)
                 return;
 
             if (typeof(Value) == typeof(SpanByte) && typeof(Input) == typeof(SpanByte))
@@ -181,14 +222,14 @@ public LockableUnsafeContext<Key, Value, Input, Output, Context, Functions> GetL
         }
 
         /// <summary>
-        /// Return a new interface to Faster operations that supports manual locking.
+        /// Return a session wrapper that supports manual locking.
         /// </summary>
-        public LockableContext<Key, Value, Input, Output, Context, Functions> GetLockableContext()
-        {
-            this.lContext ??= new(this);
-            this.lContext.Acquire();
-            return this.lContext;
-        }
+        public LockableContext<Key, Value, Input, Output, Context, Functions> LockableContext => lContext;
+
+        /// <summary>
+        /// Return a session wrapper struct that passes through to client session
+        /// </summary>
+        public BasicContext<Key, Value, Input, Output, Context, Functions> BasicContext => bContext;
 
         #region IFasterContext
         /// <inheritdoc/>
diff --git a/cs/src/core/ClientSession/LockableContext.cs b/cs/src/core/ClientSession/LockableContext.cs
index d40a1a47c..6eeda711b 100644
--- a/cs/src/core/ClientSession/LockableContext.cs
+++ b/cs/src/core/ClientSession/LockableContext.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT license.
 
-using System;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
 using System.Threading;
@@ -12,23 +11,11 @@ namespace FASTER.core
     /// <summary>
     /// Faster Context implementation that allows manual control of record locking and epoch management. For advanced use only.
     /// </summary>
-    public sealed class LockableContext<Key, Value, Input, Output, Context, Functions> : IFasterContext<Key, Value, Input, Output, Context>, ILockableContext<Key>, IDisposable
+    public readonly struct LockableContext<Key, Value, Input, Output, Context, Functions> : IFasterContext<Key, Value, Input, Output, Context>, ILockableContext<Key>
         where Functions : IFunctions<Key, Value, Input, Output, Context>
     {
         readonly ClientSession<Key, Value, Input, Output, Context, Functions> clientSession;
-
-        internal readonly InternalFasterSession FasterSession;
-        bool isAcquired;
-
-        ulong TotalLockCount => sharedLockCount + exclusiveLockCount;
-        internal ulong sharedLockCount;
-        internal ulong exclusiveLockCount;
-
-        void CheckAcquired()
-        {
-            if (!isAcquired)
-                throw new FasterException("Method call on unacquired LockableContext");
-        }
+        readonly InternalFasterSession FasterSession;
 
         internal LockableContext(ClientSession<Key, Value, Input, Output, Context, Functions> clientSession)
         {
@@ -40,7 +27,7 @@ internal LockableContext(ClientSession<Key, Value, Input, Output, Context, Funct
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void UnsafeResumeThread()
         {
-            CheckAcquired();
+            clientSession.CheckAcquired();
             Debug.Assert(!clientSession.fht.epoch.ThisInstanceProtected());
             clientSession.UnsafeResumeThread();
         }
@@ -49,7 +36,7 @@ public void UnsafeResumeThread()
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void UnsafeResumeThread(out int resumeEpoch)
         {
-            CheckAcquired();
+            clientSession.CheckAcquired();
             Debug.Assert(!clientSession.fht.epoch.ThisInstanceProtected());
             clientSession.UnsafeResumeThread(out resumeEpoch);
         }
@@ -58,7 +45,7 @@ public void UnsafeResumeThread(out int resumeEpoch)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void UnsafeSuspendThread()
         {
-            CheckAcquired();
+            clientSession.CheckAcquired();
             Debug.Assert(clientSession.fht.epoch.ThisInstanceProtected());
             clientSession.UnsafeSuspendThread();
         }
@@ -67,26 +54,25 @@ public void UnsafeSuspendThread()
         public int LocalCurrentEpoch => clientSession.fht.epoch.LocalCurrentEpoch;
 
         #region Acquire and Dispose
-        internal void Acquire()
+
+        /// <summary>
+        /// Acquire a lockable context
+        /// </summary>
+        public void Acquire()
         {
-            this.clientSession.fht.IncrementNumLockingSessions();
-            if (this.isAcquired)
-                throw new FasterException("Trying to acquire an already-acquired LockableContext");
-            this.isAcquired = true;
+            clientSession.Acquire();
         }
 
         /// <summary>
-        /// Does not actually dispose of anything; asserts the epoch has been suspended
+        /// Release a lockable context; does not actually dispose of anything
         /// </summary>
-        public void Dispose()
+        public void Release()
         {
-            CheckAcquired();
             if (clientSession.fht.epoch.ThisInstanceProtected())
-                throw new FasterException("Disposing LockableContext with a protected epoch; must call UnsafeSuspendThread");
-            if (TotalLockCount > 0)
-                throw new FasterException($"Disposing LockableContext with locks held: {sharedLockCount} shared locks, {exclusiveLockCount} exclusive locks");
-            this.isAcquired = false;
-            this.clientSession.fht.DecrementNumLockingSessions();
+                throw new FasterException("Releasing LockableContext with a protected epoch; must call UnsafeSuspendThread");
+            if (clientSession.TotalLockCount > 0)
+                throw new FasterException($"Releasing LockableContext with locks held: {clientSession.sharedLockCount} shared locks, {clientSession.exclusiveLockCount} exclusive locks");
+            clientSession.Release();
         }
         #endregion Acquire and Dispose
 
@@ -95,7 +81,7 @@ public void Dispose()
         /// <inheritdoc/>
         public unsafe void Lock(ref Key key, LockType lockType)
         {
-            CheckAcquired();
+            clientSession.CheckAcquired();
             Debug.Assert(!clientSession.fht.epoch.ThisInstanceProtected());
             clientSession.UnsafeResumeThread();
             try
@@ -110,9 +96,9 @@ public unsafe void Lock(ref Key key, LockType lockType)
                 Debug.Assert(status == OperationStatus.SUCCESS);
 
                 if (lockType == LockType.Exclusive)
-                    ++this.exclusiveLockCount;
+                    ++clientSession.exclusiveLockCount;
                 else
-                    ++this.sharedLockCount;
+                    ++clientSession.sharedLockCount;
             }
             finally
             {
@@ -126,7 +112,7 @@ public unsafe void Lock(ref Key key, LockType lockType)
         /// <inheritdoc/>
         public void Unlock(ref Key key, LockType lockType)
         {
-            CheckAcquired();
+            clientSession.CheckAcquired();
             Debug.Assert(!clientSession.fht.epoch.ThisInstanceProtected());
             clientSession.UnsafeResumeThread();
             try
@@ -141,9 +127,9 @@ public void Unlock(ref Key key, LockType lockType)
                 Debug.Assert(status == OperationStatus.SUCCESS);
 
                 if (lockType == LockType.Exclusive)
-                    --this.exclusiveLockCount;
+                    --clientSession.exclusiveLockCount;
                 else
-                    --this.sharedLockCount;
+                    --clientSession.sharedLockCount;
             }
             finally
             {
@@ -157,7 +143,7 @@ public void Unlock(ref Key key, LockType lockType)
         /// <inheritdoc/>
         public (bool exclusive, byte shared) IsLocked(ref Key key)
         {
-            CheckAcquired();
+            clientSession.CheckAcquired();
             Debug.Assert(!clientSession.fht.epoch.ThisInstanceProtected());
             clientSession.UnsafeResumeThread();
             try
@@ -185,7 +171,7 @@ public void Unlock(ref Key key, LockType lockType)
         /// <summary>
         /// The session id of FasterSession
         /// </summary>
-        public int sessionID { get { return clientSession.ctx.sessionID; } }
+        public int SessionID { get { return clientSession.ctx.sessionID; } }
 
         #endregion Key Locking
 
diff --git a/cs/src/core/ClientSession/LockableUnsafeContext.cs b/cs/src/core/ClientSession/LockableUnsafeContext.cs
index 17d0d7fda..054f04dc6 100644
--- a/cs/src/core/ClientSession/LockableUnsafeContext.cs
+++ b/cs/src/core/ClientSession/LockableUnsafeContext.cs
@@ -16,19 +16,7 @@ public sealed class LockableUnsafeContext<Key, Value, Input, Output, Context, Fu
         where Functions : IFunctions<Key, Value, Input, Output, Context>
     {
         readonly ClientSession<Key, Value, Input, Output, Context, Functions> clientSession;
-
         internal readonly InternalFasterSession FasterSession;
-        bool isAcquired;
-
-        ulong TotalLockCount => sharedLockCount + exclusiveLockCount;
-        internal ulong sharedLockCount;
-        internal ulong exclusiveLockCount;
-
-        void CheckAcquired()
-        {
-            if (!isAcquired)
-                throw new FasterException("Method call on not-acquired LockableUnsafeContext");
-        }
 
         internal LockableUnsafeContext(ClientSession<Key, Value, Input, Output, Context, Functions> clientSession)
         {
@@ -40,7 +28,7 @@ internal LockableUnsafeContext(ClientSession<Key, Value, Input, Output, Context,
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ResumeThread()
         {
-            CheckAcquired();
+            clientSession.CheckAcquired();
             clientSession.UnsafeResumeThread();
         }
 
@@ -48,7 +36,7 @@ public void ResumeThread()
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void ResumeThread(out int resumeEpoch)
         {
-            CheckAcquired();
+            clientSession.CheckAcquired();
             clientSession.UnsafeResumeThread(out resumeEpoch);
         }
 
@@ -56,6 +44,7 @@ public void ResumeThread(out int resumeEpoch)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void SuspendThread()
         {
+            clientSession.CheckAcquired();
             Debug.Assert(clientSession.fht.epoch.ThisInstanceProtected());
             clientSession.UnsafeSuspendThread();
         }
@@ -66,10 +55,7 @@ public void SuspendThread()
         #region Acquire and Dispose
         internal void Acquire()
         {
-            this.clientSession.fht.IncrementNumLockingSessions();
-            if (this.isAcquired)
-                throw new FasterException("Trying to acquire an already-acquired LockableUnsafeContext");
-            this.isAcquired = true;
+            clientSession.Acquire();
         }
 
         /// <summary>
@@ -79,10 +65,9 @@ public void Dispose()
         {
             if (clientSession.fht.epoch.ThisInstanceProtected())
                 throw new FasterException("Disposing LockableUnsafeContext with a protected epoch; must call UnsafeSuspendThread");
-            if (TotalLockCount > 0)
-                throw new FasterException($"Disposing LockableUnsafeContext with locks held: {sharedLockCount} shared locks, {exclusiveLockCount} exclusive locks");
-            this.isAcquired = false;
-            this.clientSession.fht.DecrementNumLockingSessions();
+            if (clientSession.TotalLockCount > 0)
+                throw new FasterException($"Disposing LockableUnsafeContext with locks held: {clientSession.sharedLockCount} shared locks, {clientSession.exclusiveLockCount} exclusive locks");
+            clientSession.Release();
         }
         #endregion Acquire and Dispose
 
@@ -91,7 +76,7 @@ public void Dispose()
         /// <inheritdoc/>
         public unsafe void Lock(ref Key key, LockType lockType)
         {
-            CheckAcquired();
+            clientSession.CheckAcquired();
             Debug.Assert(clientSession.fht.epoch.ThisInstanceProtected(), "Epoch protection required for Lock()");
 
             LockOperation lockOp = new(LockOperationType.Lock, lockType);
@@ -104,9 +89,9 @@ public unsafe void Lock(ref Key key, LockType lockType)
             Debug.Assert(status == OperationStatus.SUCCESS);
 
             if (lockType == LockType.Exclusive)
-                ++this.exclusiveLockCount;
+                ++clientSession.exclusiveLockCount;
             else
-                ++this.sharedLockCount;
+                ++clientSession.sharedLockCount;
         }
 
         /// <inheritdoc/>
@@ -115,7 +100,7 @@ public unsafe void Lock(ref Key key, LockType lockType)
         /// <inheritdoc/>
         public void Unlock(ref Key key, LockType lockType)
         {
-            CheckAcquired();
+            clientSession.CheckAcquired();
             Debug.Assert(clientSession.fht.epoch.ThisInstanceProtected(), "Epoch protection required for Unlock()");
 
             LockOperation lockOp = new(LockOperationType.Unlock, lockType);
@@ -128,9 +113,9 @@ public void Unlock(ref Key key, LockType lockType)
             Debug.Assert(status == OperationStatus.SUCCESS);
 
             if (lockType == LockType.Exclusive)
-                --this.exclusiveLockCount;
+                --clientSession.exclusiveLockCount;
             else
-                --this.sharedLockCount;
+                --clientSession.sharedLockCount;
         }
 
         /// <inheritdoc/>
@@ -139,7 +124,7 @@ public void Unlock(ref Key key, LockType lockType)
         /// <inheritdoc/>
         public (bool exclusive, byte shared) IsLocked(ref Key key)
         {
-            CheckAcquired();
+            clientSession.CheckAcquired();
             Debug.Assert(clientSession.fht.epoch.ThisInstanceProtected(), "Epoch protection required for IsLocked()");
 
             LockOperation lockOp = new(LockOperationType.IsLocked, LockType.None);
@@ -160,7 +145,7 @@ public void Unlock(ref Key key, LockType lockType)
         /// <summary>
         /// The session id of FasterSession
         /// </summary>
-        public int sessionID { get { return clientSession.ctx.sessionID; } }
+        public int SessionID { get { return clientSession.ctx.sessionID; } }
 
         #endregion Key Locking
 
diff --git a/cs/src/core/FasterLog/FasterLogIterator.cs b/cs/src/core/FasterLog/FasterLogIterator.cs
index 115a2a5f0..4721f3104 100644
--- a/cs/src/core/FasterLog/FasterLogIterator.cs
+++ b/cs/src/core/FasterLog/FasterLogIterator.cs
@@ -551,10 +551,11 @@ public override void Dispose()
                 if (name != null)
                     fasterLog.PersistedIterators.TryRemove(name, out _);
 
+                if (Interlocked.Decrement(ref fasterLog.logRefCount) == 0)
+                    fasterLog.TrueDispose();
+
                 disposed = true;
             }
-            if (Interlocked.Decrement(ref fasterLog.logRefCount) == 0)
-                fasterLog.TrueDispose();
         }
 
         internal override void AsyncReadPagesFromDeviceToFrame<TContext>(long readPageStart, int numPages, long untilAddress, TContext context, out CountdownEvent completed, long devicePageOffset = 0, IDevice device = null, IDevice objectLogDevice = null, CancellationTokenSource cts = null)
diff --git a/cs/test/LockableUnsafeContextTests.cs b/cs/test/LockableUnsafeContextTests.cs
index 56637506c..16b5c9ebe 100644
--- a/cs/test/LockableUnsafeContextTests.cs
+++ b/cs/test/LockableUnsafeContextTests.cs
@@ -145,21 +145,21 @@ void PrepareRecordLocation(FlushMode recordLocation)
                 this.fht.Log.FlushAndEvict(wait: true);
         }
 
-        static void ClearCountsOnError(LockableUnsafeContext<int, int, int, int, Empty, LockableUnsafeFunctions> luContext)
+        static void ClearCountsOnError(ClientSession<int, int, int, int, Empty, LockableUnsafeFunctions> luContext)
         {
             // If we already have an exception, clear these counts so "Run" will not report them spuriously.
             luContext.sharedLockCount = 0;
             luContext.exclusiveLockCount = 0;
         }
 
-        static void ClearCountsOnError(LockableUnsafeContext<int, int, int, int, Empty, IFunctions<int, int, int, int, Empty>> luContext)
+        static void ClearCountsOnError(ClientSession<int, int, int, int, Empty, IFunctions<int, int, int, int, Empty>> luContext)
         {
             // If we already have an exception, clear these counts so "Run" will not report them spuriously.
             luContext.sharedLockCount = 0;
             luContext.exclusiveLockCount = 0;
         }
 
-        static void ClearCountsOnError(LockableUnsafeContext<long, long, long, long, Empty, IFunctions<long, long, long, long, Empty>> luContext)
+        static void ClearCountsOnError(ClientSession<long, long, long, long, Empty, IFunctions<long, long, long, long, Empty>> luContext)
         {
             // If we already have an exception, clear these counts so "Run" will not report them spuriously.
             luContext.sharedLockCount = 0;
@@ -409,7 +409,7 @@ public void InMemorySimpleLockTxnTest([Values] ResultLockTarget resultLockTarget
                 }
                 catch (Exception)
                 {
-                    ClearCountsOnError(luContext);
+                    ClearCountsOnError(session);
                     throw;
                 }
                 finally
@@ -496,7 +496,7 @@ public void InMemoryLongLockTest([Values] ResultLockTarget resultLockTarget, [Va
             }
             catch (Exception)
             {
-                ClearCountsOnError(luContext);
+                ClearCountsOnError(session);
                 throw;
             }
             finally
@@ -554,7 +554,7 @@ public void InMemoryDeleteTest([Values] ResultLockTarget resultLockTarget, [Valu
                 }
                 catch (Exception)
                 {
-                    ClearCountsOnError(luContext);
+                    ClearCountsOnError(session);
                     throw;
                 }
                 finally
@@ -705,7 +705,7 @@ public void TransferFromLockTableToCTTTest()
             }
             catch (Exception)
             {
-                ClearCountsOnError(luContext);
+                ClearCountsOnError(session);
                 throw;
             }
             finally
@@ -757,7 +757,7 @@ public void TransferFromLockTableToUpsertTest([Values] ChainTests.RecordRegion r
             }
             catch (Exception)
             {
-                ClearCountsOnError(luContext);
+                ClearCountsOnError(session);
                 throw;
             }
             finally
@@ -799,7 +799,7 @@ public void TransferFromLockTableToRMWTest([Values] ChainTests.RecordRegion reco
             }
             catch (Exception)
             {
-                ClearCountsOnError(luContext);
+                ClearCountsOnError(session);
                 throw;
             }
             finally
@@ -846,7 +846,7 @@ public void TransferFromLockTableToDeleteTest([Values] ChainTests.RecordRegion r
             }
             catch (Exception)
             {
-                ClearCountsOnError(luContext);
+                ClearCountsOnError(session);
                 throw;
             }
             finally
@@ -894,7 +894,7 @@ public void LockAndUnlockInLockTableOnlyTest()
             }
             catch (Exception)
             {
-                ClearCountsOnError(luContext);
+                ClearCountsOnError(session);
                 throw;
             }
             finally
@@ -947,7 +947,7 @@ public void TransferFromReadOnlyToUpdateRecordTest([Values] UpdateOp updateOp)
             }
             catch (Exception)
             {
-                ClearCountsOnError(luContext);
+                ClearCountsOnError(session);
                 throw;
             }
             finally
@@ -1036,7 +1036,7 @@ void unlockKey(int key)
             }
             catch (Exception)
             {
-                ClearCountsOnError(lockLuContext);
+                ClearCountsOnError(lockSession);
                 throw;
             }
             finally
@@ -1056,7 +1056,7 @@ void locker(int key)
                 }
                 catch (Exception)
                 {
-                    ClearCountsOnError(lockLuContext);
+                    ClearCountsOnError(lockSession);
                     throw;
                 }
                 finally
@@ -1086,7 +1086,7 @@ void updater(int key)
                 }
                 catch (Exception)
                 {
-                    ClearCountsOnError(updateLuContext);
+                    ClearCountsOnError(updateSession);
                     throw;
                 }
                 finally
@@ -1131,7 +1131,7 @@ public void MultiSharedLockTest()
             }
             catch (Exception)
             {
-                ClearCountsOnError(luContext);
+                ClearCountsOnError(session);
                 throw;
             }
             finally
@@ -1202,7 +1202,7 @@ public void EvictFromMainLogToLockTableTest()
             }
             catch (Exception)
             {
-                ClearCountsOnError(luContext);
+                ClearCountsOnError(session);
                 throw;
             }
             finally
@@ -1243,7 +1243,7 @@ public async ValueTask CheckpointRecoverTest([Values] CheckpointType checkpointT
                 }
                 catch (Exception)
                 {
-                    ClearCountsOnError(luContext);
+                    ClearCountsOnError(session);
                     throw;
                 }
                 finally
@@ -1270,7 +1270,7 @@ public async ValueTask CheckpointRecoverTest([Values] CheckpointType checkpointT
                 }
                 catch (Exception)
                 {
-                    ClearCountsOnError(luContext);
+                    ClearCountsOnError(session);
                     throw;
                 }
                 finally
@@ -1302,7 +1302,7 @@ public async ValueTask CheckpointRecoverTest([Values] CheckpointType checkpointT
                 }
                 catch (Exception)
                 {
-                    ClearCountsOnError(luContext);
+                    ClearCountsOnError(session);
                     throw;
                 }
                 finally
@@ -1382,7 +1382,7 @@ async static Task PrimaryWriter(FasterKV<long, long> primaryStore, SyncMode sync
                 }
                 catch (Exception)
                 {
-                    ClearCountsOnError(luc1);
+                    ClearCountsOnError(s1);
                     throw;
                 }
                 finally
@@ -1406,7 +1406,7 @@ async static Task PrimaryWriter(FasterKV<long, long> primaryStore, SyncMode sync
             }
             catch (Exception)
             {
-                ClearCountsOnError(luc1);
+                ClearCountsOnError(s1);
                 throw;
             }
             finally
@@ -1462,7 +1462,7 @@ async static Task SecondaryReader(FasterKV<long, long> secondaryStore, SyncMode
                 }
                 catch (Exception)
                 {
-                    ClearCountsOnError(luc1);
+                    ClearCountsOnError(s1);
                     throw;
                 }
                 finally
diff --git a/cs/test/ReadCacheChainTests.cs b/cs/test/ReadCacheChainTests.cs
index 840898941..a33699e50 100644
--- a/cs/test/ReadCacheChainTests.cs
+++ b/cs/test/ReadCacheChainTests.cs
@@ -227,7 +227,7 @@ void VerifySplicedInKey(int expectedKey)
             Assert.AreEqual(expectedKey, storedKey);
         }
 
-        static void ClearCountsOnError(LockableUnsafeContext<int, int, int, int, Empty, IFunctions<int, int, int, int, Empty>> luContext)
+        static void ClearCountsOnError(ClientSession<int, int, int, int, Empty, IFunctions<int, int, int, int, Empty>> luContext)
         {
             // If we already have an exception, clear these counts so "Run" will not report them spuriously.
             luContext.sharedLockCount = 0;
@@ -531,7 +531,7 @@ public void EvictFromReadCacheToLockTableTest()
             }
             catch (Exception)
             {
-                ClearCountsOnError(luContext);
+                ClearCountsOnError(session);
                 throw;
             }
             finally
@@ -607,7 +607,7 @@ public void TransferFromLockTableToReadCacheTest()
             }
             catch (Exception)
             {
-                ClearCountsOnError(luContext);
+                ClearCountsOnError(session);
                 throw;
             }
             finally
@@ -718,7 +718,7 @@ unsafe void PopulateAndEvict()
             fht.Log.FlushAndEvict(true);
         }
 
-        static void ClearCountsOnError(LockableUnsafeContext<long, long, long, long, Empty, IFunctions<long, long, long, long, Empty>> luContext)
+        static void ClearCountsOnError(ClientSession<long, long, long, long, Empty, IFunctions<long, long, long, long, Empty>> luContext)
         {
             // If we already have an exception, clear these counts so "Run" will not report them spuriously.
             luContext.sharedLockCount = 0;
@@ -903,7 +903,7 @@ unsafe void PopulateAndEvict()
             fht.Log.FlushAndEvict(true);
         }
 
-        static void ClearCountsOnError(LockableUnsafeContext<SpanByte, SpanByte, SpanByte, SpanByteAndMemory, Empty, IFunctions<SpanByte, SpanByte, SpanByte, SpanByteAndMemory, Empty>> luContext)
+        static void ClearCountsOnError(ClientSession<SpanByte, SpanByte, SpanByte, SpanByteAndMemory, Empty, IFunctions<SpanByte, SpanByte, SpanByte, SpanByteAndMemory, Empty>> luContext)
         {
             // If we already have an exception, clear these counts so "Run" will not report them spuriously.
             luContext.sharedLockCount = 0;