Add BlazorAuthOptions & InitialAuthenticationState

Author: YuriyDurov

sample/BitzArt.Blazor.Auth.SampleApp/BitzArt.Blazor.Auth.SampleApp.Client/Program.cs

@@ -1,4 +1,5 @@
 using BitzArt.Blazor.Auth.Client;
+using Microsoft.AspNetCore.Components.Authorization;
 using Microsoft.AspNetCore.Components.WebAssembly.Hosting;
 
 namespace BitzArt.Blazor.Auth.SampleApp.Client;

sample/BitzArt.Blazor.Auth.SampleApp/BitzArt.Blazor.Auth.SampleApp.Shared/Components/UserAuthenticationPane.razor

@@ -2,6 +2,14 @@
 
 <AuthorizeView>
 
+    <Authorizing>
+        <div>
+            <h4>
+                Authorizing...
+            </h4>
+        </div>
+    </Authorizing>
+
     <NotAuthorized>
         <div>
             <h4>

sample/BitzArt.Blazor.Auth.SampleApp/BitzArt.Blazor.Auth.SampleApp.Shared/Pages/InteractiveServerPage.razor

@@ -6,4 +6,14 @@
 
 <RendererInfoPane />
 
-<UserAuthenticationPane />
+<UserAuthenticationPane />
+
+@code {
+    [CascadingParameter]
+    public Task<AuthenticationState> _authTask { get; set; }
+
+    protected override void OnParametersSet()
+    {
+        base.OnParametersSet();
+    }
+}

sample/BitzArt.Blazor.Auth.SampleApp/BitzArt.Blazor.Auth.SampleApp/Program.cs

@@ -1,5 +1,6 @@
 using BitzArt.Blazor.Auth.SampleApp.Services;
 using BitzArt.Blazor.Auth.Server;
+using Microsoft.AspNetCore.Components.Authorization;
 
 namespace BitzArt.Blazor.Auth.SampleApp;
 

src/BitzArt.Blazor.Auth.Client/Extensions/ClientSideAddBlazorAuthExtension.cs

@@ -14,9 +14,14 @@ public static class ClientSideAddBlazorAuthExtension
     /// Adds client-side Blazor.Auth services to the specified <see cref="WebAssemblyHostBuilder"/>.
     /// </summary>
     /// <param name="builder">The <see cref="WebAssemblyHostBuilder"/> to add services to.</param>
+    /// <param name="configure">An <see cref="Action"/> to configure <see cref="BlazorAuthOptions"/>.</param>
     /// <returns><see cref="WebAssemblyHostBuilder"/> to allow chaining.</returns>
-    public static WebAssemblyHostBuilder AddBlazorAuth(this WebAssemblyHostBuilder builder)
+    public static WebAssemblyHostBuilder AddBlazorAuth(this WebAssemblyHostBuilder builder, Action<BlazorAuthOptions>? configure = null)
     {
+        var options = new BlazorAuthOptions();
+        configure?.Invoke(options);
+        builder.Services.AddSingleton(options);
+
         builder.AddBlazorCookies();
         builder.Services.AddScoped<IBlazorAuthLogger, BlazorAuthLogger>();
 

src/BitzArt.Blazor.Auth.Server/Extensions/ServerSideAddBlazorAuthExtensions.cs

@@ -47,6 +47,8 @@ public static IHostApplicationBuilder AddBlazorAuth<TAuthenticationService, TIde
         configure?.Invoke(options);
         builder.Services.AddSingleton(options);
 
+        builder.Services.AddSingleton<BlazorAuthOptions>(sp => sp.GetRequiredService<BlazorAuthServerOptions>());
+
         builder.AddBlazorCookies();
         builder.Services.AddScoped<IBlazorAuthLogger, BlazorAuthLogger>();
 

src/BitzArt.Blazor.Auth.Server/Options/BlazorAuthServerOptions.cs

@@ -3,7 +3,7 @@
 /// <summary>
 /// Options for the Blazor Auth Server.
 /// </summary>
-public class BlazorAuthServerOptions
+public class BlazorAuthServerOptions : BlazorAuthOptions
 {
     /// <summary>
     /// Allows the app to operate in a non-HTTPS environment.

src/BitzArt.Blazor.Auth/Options/BlazorAuthOptions.cs

@@ -0,0 +1,14 @@
+using Microsoft.AspNetCore.Components.Authorization;
+
+namespace BitzArt.Blazor.Auth;
+
+/// <summary>
+/// Options for configuring Blazor.Auth
+/// </summary>
+public class BlazorAuthOptions
+{
+    /// <summary>
+    /// Initial authentication state to use before the real state is resolved.
+    /// </summary>
+    public AuthenticationState? InitialAuthenticationState { get; set; }
+}

src/BitzArt.Blazor.Auth/Providers/BlazorAuthAuthenticationStateProvider.cs

@@ -3,54 +3,61 @@
 namespace BitzArt.Blazor.Auth;
 
 /// <inheritdoc/>
-internal class BlazorAuthAuthenticationStateProvider : AuthenticationStateProvider
+internal class BlazorAuthAuthenticationStateProvider(IUserService userService, BlazorAuthOptions options) : AuthenticationStateProvider
 {
-    private readonly IUserService _userService;
 
-    private readonly SemaphoreSlim _semaphore;
-    private Task<AuthenticationState>? _authenticationStateTask;
+#if NET8_0
+    private readonly static object _lock = new();
+#elif NET9_0_OR_GREATER
+    private readonly static Lock _lock = new();
+#endif
 
-    public BlazorAuthAuthenticationStateProvider(IUserService userService)
-    {
-        _userService = userService;
-
-        _semaphore = new(1);
-    }
+    private Task<AuthenticationState>? _currentTask;
+    private Task<AuthenticationState>? _initialResult = options.InitialAuthenticationState is not null
+        ? Task.FromResult(options.InitialAuthenticationState)
+        : null;
 
     /// <inheritdoc/>
-    public override async Task<AuthenticationState> GetAuthenticationStateAsync()
+    public override Task<AuthenticationState> GetAuthenticationStateAsync()
     {
-        bool isPrimary = false;
-        Task<AuthenticationState>? task = null;
-
-        await _semaphore.WaitAsync();
-
-        try
+        lock (_lock)
         {
-            if (_authenticationStateTask is null)
+            if (_currentTask is not null)
             {
-                isPrimary = true;
-                task = _userService.GetAuthenticationStateAsync();
-                _authenticationStateTask = task;
+                return _currentTask;
             }
-            else
-            {
-                task = _authenticationStateTask;
-            } 
         }
-        finally
+
+        var task = ResolveStateAsync();
+
+        if (_initialResult is not null)
         {
-            _semaphore.Release();
+            return _initialResult;
         }
 
-        if (isPrimary)
+        return task;
+    }
+
+    private Task<AuthenticationState> ResolveStateAsync()
+    {
+        try
         {
-            NotifyAuthenticationStateChanged(_authenticationStateTask);
-            var result = await task;
-            _authenticationStateTask = null;
-            return result;
+            _currentTask = userService.GetAuthenticationStateAsync();
+            return _currentTask;
         }
+        finally
+        {
+            NotifyAuthenticationStateChanged(_currentTask!);
 
-        return await task!;
+            if (_initialResult is not null)
+            {
+                _initialResult = _currentTask;
+            }
+
+            lock (_lock)
+            {
+                _currentTask = null;
+            }
+        }
     }
 }

tests/BitzArt.Blazor.Auth.Tests/BlazorAuthAuthenticationStateProviderTests.cs

@@ -28,7 +28,7 @@ public Task SignOutAsync(CancellationToken cancellationToken = default)
     public async Task GetAuthenticationStateAsync_Simaltaneous_ShouldReuseTheSameRequest()
     {
         // Arrange
-        var provider = new BlazorAuthAuthenticationStateProvider(new TestUserService());
+        var provider = new BlazorAuthAuthenticationStateProvider(new TestUserService(), new());
 
         // Act
         var primaryTask = provider.GetAuthenticationStateAsync();