Resolve some Messages in IDE, down to 80 now.

Author: kallievz

src/BuildingBlocks/Blazor.UI/Blazor.UI.csproj

@@ -5,7 +5,7 @@
 		<AssemblyName>FSH.Framework.Blazor.UI</AssemblyName>
 		<PackageId>FullStackHero.Framework.Blazor.UI</PackageId>
 		<!-- MUD0002: MudBlazor analyzer false positives for valid component parameter usage in RenderFragment/component contexts -->
-		<NoWarn>$(NoWarn);MUD0002</NoWarn>
+		<NoWarn>$(NoWarn);MUD0002;NU1507</NoWarn>
 
 		<!-- Enable CSS isolation for Razor Class Library -->
 		<GenerateScopedCssFiles>true</GenerateScopedCssFiles>

src/BuildingBlocks/Blazor.UI/Components/Feedback/Snackbar/FshSnackbar.razor.cs

@@ -5,22 +5,15 @@ namespace FSH.Framework.Blazor.UI.Components.Feedback.Snackbar;
 /// <summary>
 /// Convenience wrapper for snackbar calls with consistent styling.
 /// </summary>
-public sealed class FshSnackbar
+public sealed class FshSnackbar(ISnackbar snackbar)
 {
-    private readonly ISnackbar _snackbar;
-
-    public FshSnackbar(ISnackbar snackbar)
-    {
-        _snackbar = snackbar;
-    }
-
     public void Success(string message) => Add(message, Severity.Success);
     public void Info(string message) => Add(message, Severity.Info);
     public void Warning(string message) => Add(message, Severity.Warning);
     public void Error(string message) => Add(message, Severity.Error);
 
     private void Add(string message, Severity severity)
     {
-        _snackbar.Add(message, severity);
+        snackbar.Add(message, severity);
     }
 }

src/BuildingBlocks/Caching/Caching.csproj

@@ -4,6 +4,7 @@
 		<RootNamespace>FSH.Framework.Caching</RootNamespace>
 		<AssemblyName>FSH.Framework.Caching</AssemblyName>
 		<PackageId>FullStackHero.Framework.Caching</PackageId>
+    <NoWarn>$(NoWarn);NU1507</NoWarn>
 	</PropertyGroup>
 
 	<ItemGroup>

src/BuildingBlocks/Core/Core.csproj

@@ -4,6 +4,7 @@
 	    <RootNamespace>FSH.Framework.Core</RootNamespace>
 	    <AssemblyName>FSH.Framework.Core</AssemblyName>
 	    <PackageId>FullStackHero.Framework.Core</PackageId>
+      <NoWarn>$(NoWarn);NU1507</NoWarn>
     </PropertyGroup>
 
 	<ItemGroup>

src/BuildingBlocks/Eventing.Abstractions/Eventing.Abstractions.csproj

@@ -8,7 +8,7 @@
 		<AssemblyName>FSH.Framework.Eventing.Abstractions</AssemblyName>
 		<PackageId>FullStackHero.Framework.Eventing.Abstractions</PackageId>
 		<Description>Lightweight abstractions for FSH eventing - interfaces only, no implementation dependencies</Description>
-		<NoWarn>$(NoWarn);CA1711;CA1716</NoWarn>
+		<NoWarn>$(NoWarn);CA1711;CA1716;NU1507</NoWarn>
 	</PropertyGroup>
 
 </Project>

src/BuildingBlocks/Eventing/Eventing.csproj

@@ -7,7 +7,7 @@
     <RootNamespace>FSH.Framework.Eventing</RootNamespace>
     <AssemblyName>FSH.Framework.Eventing</AssemblyName>
     <PackageId>FullStackHero.Framework.Eventing</PackageId>
-    <NoWarn>$(NoWarn);CA1711;CA1716;CA1031;S2139;S1066</NoWarn>
+    <NoWarn>$(NoWarn);CA1711;CA1716;CA1031;S2139;S1066;NU1507</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>

src/BuildingBlocks/Eventing/InMemory/InMemoryEventBus.cs

@@ -10,17 +10,8 @@ namespace FSH.Framework.Eventing.InMemory;
 /// In-memory event bus implementation used for single-process deployments.
 /// It resolves handlers from DI and optionally uses an inbox store for idempotency.
 /// </summary>
-public sealed partial class InMemoryEventBus : IEventBus
+public sealed partial class InMemoryEventBus(IServiceProvider serviceProvider, ILogger<InMemoryEventBus> logger) : IEventBus
 {
-    private readonly IServiceProvider _serviceProvider;
-    private readonly ILogger<InMemoryEventBus> _logger;
-
-    public InMemoryEventBus(IServiceProvider serviceProvider, ILogger<InMemoryEventBus> logger)
-    {
-        _serviceProvider = serviceProvider;
-        _logger = logger;
-    }
-
     public Task PublishAsync(IIntegrationEvent @event, CancellationToken ct = default)
         => PublishAsync(new[] { @event }, ct);
 
@@ -39,7 +30,7 @@ private async Task PublishSingleAsync(IIntegrationEvent @event, CancellationToke
         var eventType = @event.GetType();
         LogPublishingEvent(eventType.FullName, @event.Id);
 
-        using var scope = _serviceProvider.CreateScope();
+        using var scope = serviceProvider.CreateScope();
         var provider = scope.ServiceProvider;
 
         var handlers = ResolveHandlers(provider, eventType);
@@ -80,10 +71,10 @@ private async Task InvokeHandlerAsync(
             return;
         }
 
-        var method = handlerInterfaceType.GetMethod(nameof(IIntegrationEventHandler<IIntegrationEvent>.HandleAsync));
+        var method = handlerInterfaceType.GetMethod(nameof(IIntegrationEventHandler<>.HandleAsync));
         if (method == null)
         {
-            _logger.LogWarning("Handler {Handler} does not implement HandleAsync correctly for {EventType}", handlerName, eventType.FullName);
+            logger.LogWarning("Handler {Handler} does not implement HandleAsync correctly for {EventType}", handlerName, eventType.FullName);
             return;
         }
 
@@ -119,7 +110,7 @@ await inbox.MarkProcessedAsync(@event.Id, handlerName, @event.TenantId, eventTyp
         // failures are captured regardless of exception type.
         catch (Exception ex)
         {
-            _logger.LogError(ex, "Error while handling integration event {EventId} with handler {Handler}", @event.Id, handlerName);
+            logger.LogError(ex, "Error while handling integration event {EventId} with handler {Handler}", @event.Id, handlerName);
             throw;
         }
     }

src/BuildingBlocks/Eventing/Inbox/EfCoreInboxStore.cs

@@ -6,21 +6,12 @@ namespace FSH.Framework.Eventing.Inbox;
 /// EF Core-based inbox store for a specific DbContext.
 /// </summary>
 /// <typeparam name="TDbContext">The DbContext that owns the InboxMessages set.</typeparam>
-public sealed class EfCoreInboxStore<TDbContext> : IInboxStore
+public sealed class EfCoreInboxStore<TDbContext>(TDbContext dbContext, TimeProvider timeProvider) : IInboxStore
     where TDbContext : DbContext
 {
-    private readonly TDbContext _dbContext;
-    private readonly TimeProvider _timeProvider;
-
-    public EfCoreInboxStore(TDbContext dbContext, TimeProvider timeProvider)
-    {
-        _dbContext = dbContext;
-        _timeProvider = timeProvider;
-    }
-
     public async Task<bool> HasProcessedAsync(Guid eventId, string handlerName, CancellationToken ct = default)
     {
-        return await _dbContext.Set<InboxMessage>()
+        return await dbContext.Set<InboxMessage>()
             .AnyAsync(i => i.Id == eventId && i.HandlerName == handlerName, ct)
             .ConfigureAwait(false);
     }
@@ -33,10 +24,10 @@ public async Task MarkProcessedAsync(Guid eventId, string handlerName, string? t
             EventType = eventType,
             HandlerName = handlerName,
             TenantId = tenantId,
-            ProcessedOnUtc = _timeProvider.GetUtcNow().UtcDateTime
+            ProcessedOnUtc = timeProvider.GetUtcNow().UtcDateTime
         };
 
-        await _dbContext.Set<InboxMessage>().AddAsync(message, ct).ConfigureAwait(false);
-        await _dbContext.SaveChangesAsync(ct).ConfigureAwait(false);
+        await dbContext.Set<InboxMessage>().AddAsync(message, ct).ConfigureAwait(false);
+        await dbContext.SaveChangesAsync(ct).ConfigureAwait(false);
     }
 }

src/BuildingBlocks/Eventing/Inbox/InboxMessage.cs

@@ -19,20 +19,13 @@ public class InboxMessage
     public string? TenantId { get; set; }
 }
 
-public class InboxMessageConfiguration : IEntityTypeConfiguration<InboxMessage>
+public class InboxMessageConfiguration(string schema) : IEntityTypeConfiguration<InboxMessage>
 {
-    private readonly string _schema;
-
-    public InboxMessageConfiguration(string schema)
-    {
-        _schema = schema;
-    }
-
     public void Configure(EntityTypeBuilder<InboxMessage> builder)
     {
         ArgumentNullException.ThrowIfNull(builder);
 
-        builder.ToTable("InboxMessages", _schema);
+        builder.ToTable("InboxMessages", schema);
 
         builder.HasKey(i => new { i.Id, i.HandlerName });
 

src/BuildingBlocks/Eventing/Outbox/EfCoreOutboxStore.cs

@@ -8,31 +8,18 @@ namespace FSH.Framework.Eventing.Outbox;
 /// EF Core-based outbox store for a specific DbContext.
 /// </summary>
 /// <typeparam name="TDbContext">The DbContext that owns the OutboxMessages set.</typeparam>
-public sealed class EfCoreOutboxStore<TDbContext> : IOutboxStore
+public sealed class EfCoreOutboxStore<TDbContext>(
+    TDbContext dbContext,
+    IEventSerializer serializer,
+    ILogger<EfCoreOutboxStore<TDbContext>> logger,
+    TimeProvider timeProvider) : IOutboxStore
     where TDbContext : DbContext
 {
-    private readonly TDbContext _dbContext;
-    private readonly IEventSerializer _serializer;
-    private readonly ILogger<EfCoreOutboxStore<TDbContext>> _logger;
-    private readonly TimeProvider _timeProvider;
-
-    public EfCoreOutboxStore(
-        TDbContext dbContext,
-        IEventSerializer serializer,
-        ILogger<EfCoreOutboxStore<TDbContext>> logger,
-        TimeProvider timeProvider)
-    {
-        _dbContext = dbContext;
-        _serializer = serializer;
-        _logger = logger;
-        _timeProvider = timeProvider;
-    }
-
     public async Task AddAsync(IIntegrationEvent @event, CancellationToken ct = default)
     {
         ArgumentNullException.ThrowIfNull(@event);
 
-        var payload = _serializer.Serialize(@event);
+        var payload = serializer.Serialize(@event);
         var message = new OutboxMessage
         {
             Id = @event.Id,
@@ -45,13 +32,13 @@ public async Task AddAsync(IIntegrationEvent @event, CancellationToken ct = defa
             IsDead = false
         };
 
-        await _dbContext.Set<OutboxMessage>().AddAsync(message, ct).ConfigureAwait(false);
-        await _dbContext.SaveChangesAsync(ct).ConfigureAwait(false);
+        await dbContext.Set<OutboxMessage>().AddAsync(message, ct).ConfigureAwait(false);
+        await dbContext.SaveChangesAsync(ct).ConfigureAwait(false);
     }
 
     public async Task<IReadOnlyList<OutboxMessage>> GetPendingBatchAsync(int batchSize, CancellationToken ct = default)
     {
-        return await _dbContext.Set<OutboxMessage>()
+        return await dbContext.Set<OutboxMessage>()
             .Where(m => !m.IsDead && m.ProcessedOnUtc == null)
             .OrderBy(m => m.CreatedOnUtc)
             .Take(batchSize)
@@ -63,9 +50,9 @@ public async Task MarkAsProcessedAsync(OutboxMessage message, CancellationToken
     {
         ArgumentNullException.ThrowIfNull(message);
 
-        message.ProcessedOnUtc = _timeProvider.GetUtcNow().UtcDateTime;
-        _dbContext.Set<OutboxMessage>().Update(message);
-        await _dbContext.SaveChangesAsync(ct).ConfigureAwait(false);
+        message.ProcessedOnUtc = timeProvider.GetUtcNow().UtcDateTime;
+        dbContext.Set<OutboxMessage>().Update(message);
+        await dbContext.SaveChangesAsync(ct).ConfigureAwait(false);
     }
 
     public async Task MarkAsFailedAsync(OutboxMessage message, string error, bool isDead, CancellationToken ct = default)
@@ -75,11 +62,11 @@ public async Task MarkAsFailedAsync(OutboxMessage message, string error, bool is
         message.RetryCount++;
         message.LastError = error;
         message.IsDead = isDead;
-        _dbContext.Set<OutboxMessage>().Update(message);
+        dbContext.Set<OutboxMessage>().Update(message);
 
-        _logger.LogWarning("Outbox message {MessageId} failed. RetryCount={RetryCount}, IsDead={IsDead}, Error={Error}",
+        logger.LogWarning("Outbox message {MessageId} failed. RetryCount={RetryCount}, IsDead={IsDead}, Error={Error}",
             message.Id, message.RetryCount, message.IsDead, error);
 
-        await _dbContext.SaveChangesAsync(ct).ConfigureAwait(false);
+        await dbContext.SaveChangesAsync(ct).ConfigureAwait(false);
     }
 }