Eliminate boxing when entering critical sections

src/EFCore/Infrastructure/ConcurrencyDetectorCriticalSectionDisposer.cs

@@ -0,0 +1,28 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+
+namespace Microsoft.EntityFrameworkCore.Infrastructure
+{
+    /// <summary>
+    ///     A <see cref="IDisposable" /> returned by an <see cref="IConcurrencyDetector" />, which will exit the ongoing
+    ///     critical section when disposed.
+    /// </summary>
+    public class ConcurrencyDetectorCriticalSectionDisposer : IDisposable
+    {
+        private readonly IConcurrencyDetector _concurrencyDetector;
+
+        /// <summary>
+        ///    Constructs a new <see cref="ConcurrencyDetectorCriticalSectionDisposer" />.
+        /// </summary>
+        /// <param name="concurrencyDetector">
+        ///     The <see cref="IConcurrencyDetector" /> on which the critical section will be exited.
+        /// </param>
+        public ConcurrencyDetectorCriticalSectionDisposer(IConcurrencyDetector concurrencyDetector)
+            => _concurrencyDetector = concurrencyDetector;
+
+        /// <inheritdoc />
+        public void Dispose() => _concurrencyDetector.ExitCriticalSection();
+    }
+}

src/EFCore/Infrastructure/IConcurrencyDetector.cs

@@ -21,9 +21,14 @@ namespace Microsoft.EntityFrameworkCore.Infrastructure
     public interface IConcurrencyDetector
     {
         /// <summary>
-        ///     Call to enter the critical section.
+        ///     Enters a critical section.
         /// </summary>
         /// <returns> A disposer that will exit the critical section when disposed. </returns>
-        IDisposable EnterCriticalSection();
+        ConcurrencyDetectorCriticalSectionDisposer EnterCriticalSection();
+
+        /// <summary>
+        ///     Exits the critical section.
+        /// </summary>
+        void ExitCriticalSection();
     }
 }

src/EFCore/Internal/ConcurrencyDetector.cs

@@ -26,7 +26,6 @@ namespace Microsoft.EntityFrameworkCore.Internal
     /// </summary>
     public class ConcurrencyDetector : IConcurrencyDetector
     {
-        private readonly IDisposable _disposer;
         private int _inCriticalSection;
         private static readonly AsyncLocal<bool> _threadHasLock = new AsyncLocal<bool>();
         private int _refCount;
@@ -37,15 +36,7 @@ public class ConcurrencyDetector : IConcurrencyDetector
         ///     any release. You should only use it directly in your code with extreme caution and knowing that
         ///     doing so can result in application failures when updating to a new Entity Framework Core release.
         /// </summary>
-        public ConcurrencyDetector() => _disposer = new Disposer(this);
-
-        /// <summary>
-        ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
-        ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
-        ///     any release. You should only use it directly in your code with extreme caution and knowing that
-        ///     doing so can result in application failures when updating to a new Entity Framework Core release.
-        /// </summary>
-        public virtual IDisposable EnterCriticalSection()
+        public virtual ConcurrencyDetectorCriticalSectionDisposer EnterCriticalSection()
         {
             if (Interlocked.CompareExchange(ref _inCriticalSection, 1, 0) == 1)
             {
@@ -60,10 +51,16 @@ public virtual IDisposable EnterCriticalSection()
             }
 
             _refCount++;
-            return _disposer;
+            return new ConcurrencyDetectorCriticalSectionDisposer(this);
         }
 
-        private void ExitCriticalSection()
+        /// <summary>
+        ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+        ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+        ///     any release. You should only use it directly in your code with extreme caution and knowing that
+        ///     doing so can result in application failures when updating to a new Entity Framework Core release.
+        /// </summary>
+        public virtual void ExitCriticalSection()
         {
             Check.DebugAssert(_inCriticalSection == 1, "Expected to be in a critical section");
 
@@ -73,15 +70,5 @@ private void ExitCriticalSection()
                 _inCriticalSection = 0;
             }
         }
-
-        private readonly struct Disposer : IDisposable
-        {
-            private readonly ConcurrencyDetector _concurrencyDetector;
-
-            public Disposer(ConcurrencyDetector concurrencyDetector)
-                => _concurrencyDetector = concurrencyDetector;
-
-            public void Dispose() => _concurrencyDetector.ExitCriticalSection();
-        }
     }
 }