Authentication provider doesn't have access to RemotingSession.

CoreRemoting.Tests/CoreRemoting.Tests.csproj

@@ -16,6 +16,7 @@
     </ItemGroup>
 
     <ItemGroup>
+        <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="7.0.0" />
         <PackageReference Include="System.Runtime.Serialization.Formatters" Version="9.0.0" Condition="'$(TargetFramework)' == 'net8.0'" />
         <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />

CoreRemoting.Tests/DisposableTests.cs

@@ -0,0 +1,57 @@
+using CoreRemoting.Toolbox;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace CoreRemoting.Tests
+{
+    public class DisposableTests
+    {
+        [Fact]
+        public void Disposable_executes_action_on_Dispose()
+        {
+            var disposed = false;
+
+            void Dispose() =>
+                disposed = true;
+
+            using (Disposable.Create(Dispose))
+                Assert.False(disposed);
+
+            Assert.True(disposed);
+        }
+
+        [Fact]
+        public async Task AsyncDisposable_executes_action_on_DisposeAsync()
+        {
+            var disposed = false;
+
+            async Task DisposeTask()
+            {
+                await Task.Yield();
+                disposed = true;
+            }
+
+            await using (Disposable.Create(DisposeTask))
+                Assert.False(disposed);
+
+            Assert.True(disposed);
+        }
+
+        [Fact]
+        public async Task AsyncTaskDisposable_executes_action_on_DisposeAsync()
+        {
+            var disposed = false;
+
+            async ValueTask DisposeAsync()
+            {
+                await Task.Yield();
+                disposed = true;
+            }
+
+            await using (Disposable.Create(DisposeAsync))
+                Assert.False(disposed);
+
+            Assert.True(disposed);
+        }
+    }
+}

CoreRemoting.Tests/RpcTests.cs

@@ -3,6 +3,7 @@
 using System.Diagnostics;
 using System.Threading;
 using System.Threading.Tasks;
+using CoreRemoting.Authentication;
 using CoreRemoting.Channels;
 using CoreRemoting.Serialization;
 using CoreRemoting.Tests.ExternalTypes;
@@ -832,8 +833,10 @@ public void Authentication_is_taken_into_account_and_RejectCall_event_is_fired()
             void RejectCall(object sender, ServerRpcContext e) =>
                 rejectedMethod = e.MethodCallMessage.MethodName;
 
-            _serverFixture.Server.Config.AuthenticationRequired = true;
-            _serverFixture.Server.RejectCall += RejectCall;
+            var server = _serverFixture.Server;
+            server.RejectCall += RejectCall;
+            server.Config.AuthenticationRequired = true;
+
             try
             {
                 using var client = new RemotingClient(new ClientConfig()
@@ -859,8 +862,44 @@ void RejectCall(object sender, ServerRpcContext e) =>
             }
             finally
             {
-                _serverFixture.Server.Config.AuthenticationRequired = false;
-                _serverFixture.Server.RejectCall -= RejectCall;
+                server.Config.AuthenticationRequired = false;
+                server.RejectCall -= RejectCall;
+            }
+        }
+
+        [Fact]
+        public void Authentication_handler_has_access_to_the_current_session()
+        {
+            var server = _serverFixture.Server;
+            var authProvider = server.Config.AuthenticationProvider;
+            server.Config.AuthenticationRequired = true;
+            server.Config.AuthenticationProvider = new FakeAuthProvider
+            {
+                AuthenticateFake = c => RemotingSession.Current != null
+            };
+
+            try
+            {
+                using var client = new RemotingClient(new ClientConfig()
+                {
+                    ConnectionTimeout = 0,
+                    InvocationTimeout = 0,
+                    SendTimeout = 0,
+                    Channel = ClientChannel,
+                    MessageEncryption = false,
+                    ServerPort = _serverFixture.Server.Config.NetworkPort,
+                    Credentials = [new Credential()],
+                });
+
+                client.Connect();
+
+                var proxy = client.CreateProxy<ITestService>();
+                Assert.Equal("123", proxy.Reverse("321"));
+            }
+            finally
+            {
+                server.Config.AuthenticationProvider = authProvider;
+                server.Config.AuthenticationRequired = false;
             }
         }
     }

CoreRemoting/IRemotingServer.cs

@@ -27,14 +27,14 @@ public interface IRemotingServer : IDisposable
         event EventHandler<ServerRpcContext> AfterCall;
 
         /// <summary>
-        /// Event: Fires if an error occurs.
+        /// Event: Fires when an RPC call is rejected before BeginCall event. .
         /// </summary>
-        event EventHandler<Exception> Error;
+        event EventHandler<ServerRpcContext> RejectCall;
 
         /// <summary>
-        /// Event: Fires when an RPC call is rejected before BeginCall event. .
+        /// Event: Fires if an error occurs.
         /// </summary>
-        event EventHandler<ServerRpcContext> RejectCall;
+        event EventHandler<Exception> Error;
 
         /// <summary>
         /// Gets the unique name of this server instance.

CoreRemoting/RemotingSession.cs

@@ -13,6 +13,7 @@
 using CoreRemoting.Encryption;
 using CoreRemoting.Serialization;
 using Serialize.Linq.Nodes;
+using CoreRemoting.Toolbox;
 
 namespace CoreRemoting
 {
@@ -258,6 +259,8 @@ private void OnReceiveMessage(byte[] rawMessage)
 
                 _currentlyProcessedMessagesCounter.AddCount(1);
 
+                CurrentSession.Value = this;
+
                 try
                 {
                     var message = _server.Serializer.Deserialize<WireMessage>(rawMessage);
@@ -285,6 +288,8 @@ private void OnReceiveMessage(byte[] rawMessage)
                 finally
                 {
                     _currentlyProcessedMessagesCounter.Signal();
+
+                    CurrentSession.Value = null;
                 }
             });
         }
@@ -424,8 +429,6 @@ private void ProcessRpcMessage(WireMessage request)
 
             try
             {
-                CurrentSession.Value = this;
-
                 if (_server.Config.AuthenticationRequired && !_isAuthenticated)
                     throw new NetworkException("Session is not authenticated.");
 
@@ -470,19 +473,13 @@ private void ProcessRpcMessage(WireMessage request)
                 serializedResult =
                     _server.Serializer.Serialize(serverRpcContext.Exception);
             }
-            finally
-            {
-                CurrentSession.Value = null;
-            }
 
             object result = null;
 
             if (serverRpcContext.Exception == null)
             {
                 try
                 {
-                    CurrentSession.Value = this;
-
                     ((RemotingServer)_server).OnBeforeCall(serverRpcContext);
 
                     result = method.Invoke(serverRpcContext.ServiceInstance,
@@ -543,10 +540,6 @@ private void ProcessRpcMessage(WireMessage request)
                     serializedResult =
                         _server.Serializer.Serialize(serverRpcContext.Exception);
                 }
-                finally
-                {
-                    CurrentSession.Value = null;
-                }
 
                 if (!oneWay)
                 {
@@ -587,8 +580,6 @@ private void ProcessRpcMessage(WireMessage request)
 
             _rawMessageTransport.SendMessage(
                 _server.Serializer.Serialize(methodResultMessage));
-
-            CurrentSession.Value = null;
         }
 
         private MethodInfo GetMethodInfo(MethodCallMessage callMessage, Type serviceInterfaceType, Type[] parameterTypes)

CoreRemoting/Toolbox/Disposable.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Threading.Tasks;
+
+namespace CoreRemoting.Toolbox
+{
+    /// <summary>
+    /// Helper class to create disposable primitives.
+    /// </summary>
+    public static class Disposable
+    {
+        private class SyncDisposable(Action disposeAction) : IDisposable
+        {
+            void IDisposable.Dispose() =>
+                disposeAction?.Invoke();
+        }
+
+        /// <summary>
+        /// Creates a disposable object.
+        /// </summary>
+        /// <param name="disposeAction">An action to invoke on disposal.</param>
+        public static IDisposable Create(Action disposeAction) =>
+            new SyncDisposable(disposeAction);
+
+        private class AsyncDisposable(
+            Func<ValueTask> disposeAsync,
+            Func<Task> disposeTaskAsync) : IAsyncDisposable
+        {
+            async ValueTask IAsyncDisposable.DisposeAsync()
+            {
+                if (disposeAsync != null)
+                    await disposeAsync();
+
+                if (disposeTaskAsync != null)
+                    await disposeTaskAsync();
+            }
+        }
+
+        /// <summary>
+        /// Creates an asynchronous disposable object.
+        /// </summary>
+        /// <param name="disposeAsync">An action to invoke on disposal.</param>
+        public static IAsyncDisposable Create(Func<ValueTask> disposeAsync) =>
+            new AsyncDisposable(disposeAsync, null);
+
+        /// <summary>
+        /// Creates an asynchronous disposable object.
+        /// </summary>
+        /// <param name="disposeAsync">An action to invoke on disposal.</param>
+        public static IAsyncDisposable Create(Func<Task> disposeAsync) =>
+            new AsyncDisposable(null, disposeAsync);
+    }
+}