PR feedback.

- Moved using statements outside of namespaces in SentryDatabaseLogging.cs and SentryCountdownLock.cs. Specified preference for this in .editorconfig.
- Renamed _init back to Init in SentryDatabaseLogging.cs.
- Moved type aliases in InterlockedBoolean.cs and InterlockedBooleanTests.cs outside of the namespace and changed them from built-in type names to explicit references to the underlying types.
- Made _value in InterlockedBoolean private and added an internal test-specific property instead.
- Added MethodImpl hints to the methods it InterlockedBoolean.cs requesting aggressive inlining.
- Changed parameters to the implicit conversion operatons in InterlockedBoolean from _this to @this.
- Standardized .Should.Be(..) assertions in InterlockedBooleanTests.cs so that the expectation is always named expected.

Author: logiclrd

src/Sentry.Azure.Functions.Worker/.editorconfig

@@ -2,4 +2,6 @@
 
 # Reason: Azure Functions worker doesn't set SynchronizationContext but Durable Functions does and required affinity.
 # (https://github.com/Azure/azure-functions-dotnet-worker/issues/1520)
-dotnet_diagnostic.CA2007.severity = none
+dotnet_diagnostic.CA2007.severity = none
+
+dotnet_style_namespace_declaration_with_usings_placement = prefer_outside_namespace

src/Sentry.EntityFramework/SentryDatabaseLogging.cs

@@ -1,20 +1,20 @@
-namespace Sentry.EntityFramework;
-
 using Sentry.Internal;
 
+namespace Sentry.EntityFramework;
+
 /// <summary>
 /// Sentry Database Logger
 /// </summary>
 internal static class SentryDatabaseLogging
 {
-    private static InterlockedBoolean _init;
+    private static InterlockedBoolean Init;
 
     internal static SentryCommandInterceptor? UseBreadcrumbs(
         IQueryLogger? queryLogger = null,
         bool initOnce = true,
         IDiagnosticLogger? diagnosticLogger = null)
     {
-        if (initOnce && _init.Exchange(true))
+        if (initOnce && Init.Exchange(true))
         {
             diagnosticLogger?.LogWarning("{0}.{1} was already executed.",
                 nameof(SentryDatabaseLogging), nameof(UseBreadcrumbs));

src/Sentry/Internal/InterlockedBoolean.cs

@@ -1,14 +1,17 @@
-namespace Sentry.Internal;
-
 #if NET9_0_OR_GREATER
-using TBool = bool;
+using TBool = System.Boolean;
 #else
-using TBool = int;
+using TBool = System.Int32;
 #endif
 
+namespace Sentry.Internal;
+
 internal struct InterlockedBoolean
 {
-    internal volatile TBool _value;
+    private volatile TBool _value;
+
+    [Browsable(false)]
+    internal TBool ValueForTests => _value;
 
 #if NET9_0_OR_GREATER
     private const TBool True = true;
@@ -20,11 +23,15 @@ internal struct InterlockedBoolean
 
     public InterlockedBoolean() { }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public InterlockedBoolean(bool value) { _value = value ? True : False; }
 
-    public static implicit operator bool(InterlockedBoolean? _this) => (_this != null) && (_this.Value._value != False);
-    public static implicit operator InterlockedBoolean(bool _this) => new InterlockedBoolean(_this);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static implicit operator bool(InterlockedBoolean @this) => (@this._value != False);
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public static implicit operator InterlockedBoolean(bool @this) => new InterlockedBoolean(@this);
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool Exchange(bool newValue)
     {
         TBool localNewValue = newValue ? True : False;
@@ -34,6 +41,7 @@ public bool Exchange(bool newValue)
         return (localReturnValue != False);
     }
 
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public bool CompareExchange(bool value, bool comparand)
     {
         TBool localValue = value ? True : False;

src/Sentry/Threading/ScopedCountdownLock.cs

@@ -1,7 +1,7 @@
-namespace Sentry.Threading;
-
 using Sentry.Internal;
 
+namespace Sentry.Threading;
+
 /// <summary>
 /// A synchronization primitive that tracks the amount of <see cref="CounterScope"/>s held,
 /// and is signaled when the count reaches zero while a <see cref="LockScope"/> is held.

test/Sentry.Tests/Internals/InterlockedBooleanTests.cs

@@ -1,11 +1,11 @@
-namespace Sentry.Tests.Internals;
-
 #if NET9_0_OR_GREATER
-using TBool = bool;
+using TBool = System.Boolean;
 #else
-using TBool = int;
+using TBool = System.Int32;
 #endif
 
+namespace Sentry.Tests.Internals;
+
 public class InterlockedBooleanTests
 {
 #if NET9_0_OR_GREATER
@@ -25,13 +25,13 @@ public class InterlockedBooleanTests
     public void InterlockedBoolean_Constructor_ConstructsExpected(bool value)
     {
         // Arrange
-        var tboolValue = ToTBool(value);
+        var expected = ToTBool(value);
 
         // Act
         var actual = new InterlockedBoolean(value);
 
         // Assert
-        actual._value.Should().Be(tboolValue);
+        actual.ValueForTests.Should().Be(expected);
     }
 
     [Theory]
@@ -41,12 +41,13 @@ public void InterlockedBoolean_ImplicitToBool_ReturnsExpected(bool value)
     {
         // Arrange
         var sut = new InterlockedBoolean(value);
+        var expected = value;
 
         // Act
         bool actual = sut;
 
         // Assert
-        actual.Should().Be(value);
+        actual.Should().Be(expected);
     }
 
     [Theory]
@@ -55,13 +56,13 @@ public void InterlockedBoolean_ImplicitToBool_ReturnsExpected(bool value)
     public void InterlockedBoolean_ImplicitFromBool_ReturnsExpected(bool value)
     {
         // Arrange
-        var tboolValue = ToTBool(value);
+        var expected = ToTBool(value);
 
         // Act
         InterlockedBoolean actual = value;
 
         // Assert
-        actual._value.Should().Be(tboolValue);
+        actual.ValueForTests.Should().Be(expected);
     }
 
     [Theory]
@@ -73,12 +74,13 @@ public void InterlockedBoolean_Exchange_ReturnsExpected(bool initialState, bool
     {
         // Arrange
         var sut = new InterlockedBoolean(initialState);
+        var expected = initialState;
 
         // Act
         var result = sut.Exchange(newValue);
 
         // Assert
-        result.Should().Be(initialState);
+        result.Should().Be(expected);
     }
 
     [Theory]
@@ -91,13 +93,13 @@ public void InterlockedBoolean_Exchange_SetsExpectedNewState(bool initialState,
         // Arrange
         var sut = new InterlockedBoolean(initialState);
 
-        var tboolNewValue = ToTBool(newValue);
+        var expected = ToTBool(newValue);
 
         // Act
         var result = sut.Exchange(newValue);
 
         // Assert
-        sut._value.Should().Be(tboolNewValue);
+        sut.ValueForTests.Should().Be(expected);
     }
 
     [Theory]
@@ -113,12 +115,13 @@ public void InterlockedBoolean_CompareExchange_ReturnsExpected(bool initialState
     {
         // Arrange
         var sut = new InterlockedBoolean(initialState);
+        var expected = initialState;
 
         // Act
         var result = sut.CompareExchange(newValue, comparand);
 
         // Assert
-        result.Should().Be(initialState);
+        result.Should().Be(expected);
     }
 
     [Theory]
@@ -135,7 +138,7 @@ public void InterlockedBoolean_CompareExchange_SetsExpectedNewState(bool initial
         // Arrange
         var sut = new InterlockedBoolean(initialState);
 
-        var tboolExpected = ToTBool(
+        var expected = ToTBool(
             initialState == comparand
             ? newValue
             : initialState);
@@ -144,6 +147,6 @@ public void InterlockedBoolean_CompareExchange_SetsExpectedNewState(bool initial
         sut.CompareExchange(newValue, comparand);
 
         // Assert
-        sut._value.Should().Be(tboolExpected);
+        sut.ValueForTests.Should().Be(expected);
     }
 }