Fix NRT errors and enable TreatWarningsAsErrors

build/common.props

@@ -16,6 +16,7 @@
     <NoWarn>$(NoWarn);CS1591;NU1701</NoWarn>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <PackageOutputPath>$(SolutionDir)artifacts</PackageOutputPath>
     <PackageIcon>foundatio-icon.png</PackageIcon>

samples/Foundatio.AzureStorage.Dequeue/Program.cs

@@ -52,6 +52,18 @@
     var mode = parseResult.GetValue(modeOption);
     var count = parseResult.GetValue(countOption);
 
+    if (string.IsNullOrWhiteSpace(connectionString))
+    {
+        Console.Error.WriteLine("Error: Connection string is required. Use --connection-string or set AZURE_STORAGE_CONNECTION_STRING.");
+        return 1;
+    }
+
+    if (string.IsNullOrWhiteSpace(queueName))
+    {
+        Console.Error.WriteLine("Error: Queue name is required. Use --queue.");
+        return 1;
+    }
+
     Console.WriteLine($"Using connection: {(connectionString == EmulatorConnectionString ? "Azure Storage Emulator" : "Custom connection string")}");
     Console.WriteLine($"Mode: {mode}");
     Console.WriteLine($"Queue: {queueName}");
@@ -120,14 +132,14 @@ static async Task DequeueMessages(string connectionString, string queueName, Azu
                 processed++;
 
                 logger.LogInformation("Dequeued message {MessageId}: '{Message}' from '{Source}' at {Timestamp}",
-                    entry.Id, entry.Value.Message, entry.Value.Source, entry.Value.Timestamp);
+                    entry.Id, entry.Value?.Message, entry.Value?.Source, entry.Value?.Timestamp);
 
                 logger.LogInformation("  CorrelationId: '{CorrelationId}'", entry.CorrelationId ?? "<none>");
 
                 if (entry.Properties != null && entry.Properties.Count > 0)
                 {
                     logger.LogInformation("  Properties: [{Properties}]",
-                        string.Join(", ", entry.Properties.Select(p => $"{p.Key}={p.Value}")));
+                        String.Join(", ", entry.Properties.Select(p => $"{p.Key}={p.Value}")));
                 }
                 else
                 {

samples/Foundatio.AzureStorage.Enqueue/Program.cs

@@ -71,10 +71,28 @@
     var queueName = parseResult.GetValue(queueOption);
     var message = parseResult.GetValue(messageOption);
     var correlationId = parseResult.GetValue(correlationIdOption);
-    var properties = parseResult.GetValue(propertiesOption);
+    var properties = parseResult.GetValue(propertiesOption) ?? [];
     var mode = parseResult.GetValue(modeOption);
     var count = parseResult.GetValue(countOption);
 
+    if (string.IsNullOrWhiteSpace(connectionString))
+    {
+        Console.Error.WriteLine("Error: Connection string is required. Use --connection-string or set AZURE_STORAGE_CONNECTION_STRING.");
+        return 1;
+    }
+
+    if (string.IsNullOrWhiteSpace(queueName))
+    {
+        Console.Error.WriteLine("Error: Queue name is required. Use --queue.");
+        return 1;
+    }
+
+    if (string.IsNullOrWhiteSpace(message))
+    {
+        Console.Error.WriteLine("Error: Message is required. Use --message.");
+        return 1;
+    }
+
     Console.WriteLine($"Using connection: {(connectionString == EmulatorConnectionString ? "Azure Storage Emulator" : "Custom connection string")}");
     Console.WriteLine($"Mode: {mode}");
     Console.WriteLine();
@@ -86,7 +104,7 @@
 // Parse and invoke
 return await rootCommand.Parse(args).InvokeAsync();
 
-static async Task EnqueueMessages(string connectionString, string queueName, string message, string correlationId, string[] properties, AzureStorageQueueCompatibilityMode mode, int count)
+static async Task EnqueueMessages(string connectionString, string queueName, string message, string? correlationId, string[] properties, AzureStorageQueueCompatibilityMode mode, int count)
 {
     using var loggerFactory = LoggerFactory.Create(builder => builder.AddConsole().SetMinimumLevel(LogLevel.Information));
     var logger = loggerFactory.CreateLogger("Enqueue");
@@ -100,15 +118,12 @@ static async Task EnqueueMessages(string connectionString, string queueName, str
         .LoggerFactory(loggerFactory));
 
     var queueProperties = new Dictionary<string, string>();
-    if (properties != null)
+    foreach (var prop in properties)
     {
-        foreach (var prop in properties)
+        var parts = prop.Split('=', 2);
+        if (parts.Length == 2)
         {
-            var parts = prop.Split('=', 2);
-            if (parts.Length == 2)
-            {
-                queueProperties[parts[0]] = parts[1];
-            }
+            queueProperties[parts[0]] = parts[1];
         }
     }
 
@@ -122,15 +137,17 @@ static async Task EnqueueMessages(string connectionString, string queueName, str
 
         var entryOptions = new QueueEntryOptions
         {
-            CorrelationId = correlationId,
-            Properties = queueProperties.Count > 0 ? queueProperties : null
+            CorrelationId = correlationId
         };
 
+        if (queueProperties.Count > 0)
+            entryOptions.Properties = queueProperties;
+
         var messageId = await queue.EnqueueAsync(sampleMessage, entryOptions);
 
         logger.LogInformation("Enqueued message {MessageId}: '{Message}' with CorrelationId: '{CorrelationId}' Properties: [{Properties}]",
             messageId, sampleMessage.Message, correlationId ?? "<none>",
-            string.Join(", ", queueProperties.Select(p => $"{p.Key}={p.Value}")));
+            String.Join(", ", queueProperties.Select(p => $"{p.Key}={p.Value}")));
     }
 
     logger.LogInformation("Successfully enqueued {Count} message(s)", count);

samples/Foundatio.AzureStorage.Enqueue/SampleMessage.cs

@@ -4,7 +4,7 @@ namespace Foundatio.AzureStorage.Samples;
 
 public record SampleMessage
 {
-    public string Message { get; init; } = string.Empty;
+    public required string Message { get; init; }
     public DateTime Timestamp { get; init; } = DateTime.UtcNow;
-    public string Source { get; init; } = string.Empty;
+    public required string Source { get; init; }
 }

src/Foundatio.AzureStorage/Foundatio.AzureStorage.csproj

@@ -7,7 +7,7 @@
     <PackageReference Include="Azure.Storage.Blobs" Version="12.27.0" />
     <PackageReference Include="Azure.Storage.Queues" Version="12.25.0" />
 
-    <PackageReference Include="Foundatio" Version="13.0.0-beta3.32" Condition="'$(ReferenceFoundatioSource)' == '' OR '$(ReferenceFoundatioSource)' == 'false'" />
+    <PackageReference Include="Foundatio" Version="13.0.0-beta3.41" Condition="'$(ReferenceFoundatioSource)' == '' OR '$(ReferenceFoundatioSource)' == 'false'" />
     <ProjectReference Include="..\..\..\Foundatio\src\Foundatio\Foundatio.csproj" Condition="'$(ReferenceFoundatioSource)' == 'true'" />
   </ItemGroup>
 </Project>

src/Foundatio.AzureStorage/Queues/AzureStorageQueue.cs

@@ -27,8 +27,7 @@ public class AzureStorageQueue<T> : QueueBase<T, AzureStorageQueueOptions<T>> wh
 
     public AzureStorageQueue(AzureStorageQueueOptions<T> options) : base(options)
     {
-        if (String.IsNullOrEmpty(options.ConnectionString))
-            throw new ArgumentException("ConnectionString is required.");
+        ArgumentException.ThrowIfNullOrWhiteSpace(options?.ConnectionString, nameof(options.ConnectionString));
 
         var clientOptions = new QueueClientOptions();
 #pragma warning disable CS0618 // Legacy mode is still supported internally for backward compatibility
@@ -71,7 +70,7 @@ await Task.WhenAll(
         }
     }
 
-    protected override async Task<string> EnqueueImplAsync(T data, QueueEntryOptions options)
+    protected override async Task<string?> EnqueueImplAsync(T data, QueueEntryOptions options)
     {
         if (!await OnEnqueuingAsync(data, options).AnyContext())
             return null;
@@ -110,7 +109,7 @@ protected override async Task<string> EnqueueImplAsync(T data, QueueEntryOptions
         return response.Value.MessageId;
     }
 
-    protected override async Task<IQueueEntry<T>> DequeueImplAsync(CancellationToken linkedCancellationToken)
+    protected override async Task<IQueueEntry<T>?> DequeueImplAsync(CancellationToken linkedCancellationToken)
     {
         _logger.LogTrace("Checking for message: IsCancellationRequested={IsCancellationRequested} VisibilityTimeout={VisibilityTimeout}", linkedCancellationToken.IsCancellationRequested, _options.WorkItemTimeout);
 
@@ -177,9 +176,10 @@ protected override async Task<IQueueEntry<T>> DequeueImplAsync(CancellationToken
             message.MessageId, insertedOn, nowUtc, queueTime.TotalMilliseconds, linkedCancellationToken.IsCancellationRequested);
         Interlocked.Increment(ref _dequeuedCount);
 
-        T data;
-        string correlationId = null;
-        IDictionary<string, string> properties = null;
+        T? data;
+        string? correlationId = null;
+        IDictionary<string, string>? properties = null;
+        Exception? deserializeException = null;
 
         try
         {
@@ -189,9 +189,16 @@ protected override async Task<IQueueEntry<T>> DequeueImplAsync(CancellationToken
                 {
                     // Unwrap envelope to extract metadata
                     var envelope = _serializer.Deserialize<QueueMessageEnvelope<T>>(message.Body.ToArray());
-                    data = envelope.Data;
-                    correlationId = envelope.CorrelationId;
-                    properties = envelope.Properties;
+                    if (envelope is not null)
+                    {
+                        data = envelope.Data;
+                        correlationId = envelope.CorrelationId;
+                        properties = envelope.Properties;
+                    }
+                    else
+                    {
+                        data = _serializer.Deserialize<T>(message.Body.ToArray());
+                    }
                 }
                 catch (Exception ex)
                 {
@@ -209,7 +216,13 @@ protected override async Task<IQueueEntry<T>> DequeueImplAsync(CancellationToken
         }
         catch (Exception ex)
         {
-            _logger.LogWarning(ex, "Error deserializing message {MessageId} (attempt {DequeueCount}), abandoning for retry", message.MessageId, message.DequeueCount);
+            data = null;
+            deserializeException = ex;
+        }
+
+        if (data is null)
+        {
+            _logger.LogWarning(deserializeException, "Error deserializing message {MessageId} (attempt {DequeueCount}), abandoning for retry", message.MessageId, message.DequeueCount);
 
             var poisonEntry = new AzureStorageQueueEntry<T>(message, null, null, null, this);
             await AbandonAsync(poisonEntry).AnyContext();
@@ -419,7 +432,7 @@ protected override void StartWorkingImpl(Func<IQueueEntry<T>, CancellationToken,
             {
                 _logger.LogTrace("WorkerLoop Signaled {QueueName}", _options.Name);
 
-                IQueueEntry<T> queueEntry = null;
+                IQueueEntry<T>? queueEntry = null;
                 try
                 {
                     queueEntry = await DequeueImplAsync(linkedCancellationToken.Token).AnyContext();
@@ -498,15 +511,15 @@ internal record QueueMessageEnvelope<T> where T : class
     /// <summary>
     /// Correlation ID for distributed tracing
     /// </summary>
-    public string CorrelationId { get; init; }
+    public string? CorrelationId { get; init; }
 
     /// <summary>
     /// Custom properties/metadata
     /// </summary>
-    public IDictionary<string, string> Properties { get; init; }
+    public IDictionary<string, string>? Properties { get; init; }
 
     /// <summary>
     /// The actual message payload
     /// </summary>
-    public T Data { get; init; }
+    public required T Data { get; init; }
 }

src/Foundatio.AzureStorage/Queues/AzureStorageQueueEntry.cs

@@ -14,7 +14,7 @@ public class AzureStorageQueueEntry<T> : QueueEntry<T> where T : class
     /// </summary>
     public string PopReceipt { get; internal set; }
 
-    public AzureStorageQueueEntry(QueueMessage message, string correlationId, IDictionary<string, string> properties, T data, IQueue<T> queue)
+    public AzureStorageQueueEntry(QueueMessage message, string? correlationId, IDictionary<string, string>? properties, T? data, IQueue<T> queue)
         : base(message.MessageId, correlationId, data, queue, message.InsertedOn?.UtcDateTime ?? DateTime.MinValue, (int)message.DequeueCount)
     {
         UnderlyingMessage = message;

src/Foundatio.AzureStorage/Queues/AzureStorageQueueOptions.cs

@@ -25,7 +25,7 @@ public enum AzureStorageQueueCompatibilityMode
 
 public class AzureStorageQueueOptions<T> : SharedQueueOptions<T> where T : class
 {
-    public string ConnectionString { get; set; }
+    public string? ConnectionString { get; set; }
 
     /// <summary>
     /// The interval to wait between polling for new messages when the queue is empty.
@@ -71,14 +71,14 @@ public class AzureStorageQueueOptions<T> : SharedQueueOptions<T> where T : class
     /// };
     /// </code>
     /// </example>
-    public Action<RetryOptions> ConfigureRetry { get; set; }
+    public Action<RetryOptions>? ConfigureRetry { get; set; }
 }
 
 public class AzureStorageQueueOptionsBuilder<T> : SharedQueueOptionsBuilder<T, AzureStorageQueueOptions<T>, AzureStorageQueueOptionsBuilder<T>> where T : class
 {
     public AzureStorageQueueOptionsBuilder<T> ConnectionString(string connectionString)
     {
-        ArgumentException.ThrowIfNullOrEmpty(connectionString);
+        ArgumentException.ThrowIfNullOrWhiteSpace(connectionString);
 
         Target.ConnectionString = connectionString;
         return this;