diff --git a/workflows/csharp/sdk/README.md b/workflows/csharp/sdk/README.md
index bd96dfd71..635afb0d9 100644
--- a/workflows/csharp/sdk/README.md
+++ b/workflows/csharp/sdk/README.md
@@ -28,12 +28,13 @@ dotnet build
 ```
 
 <!-- END_STEP -->
-2. Run the console app with Dapr: 
+2. Run the console app with Dapr. Note that you may need to run `cd ..` to move the working directory up one to 
+'/workflows/csharp/sdk': 
 
 <!-- STEP
 name: Run order-processor service
 expected_stdout_lines:
-  - "== APP - order-processor ==       There are now: 90 Cars left in stock"
+  - "== APP - order-processor ==       There are: 10 Cars available for purchase"
   - "== APP - order-processor == Workflow Status: Completed"
 expected_stderr_lines:
 output_match_mode: substring
@@ -50,33 +51,41 @@ dapr run -f .
 
 3. Expected output
 
-
 ```
-== APP == Starting workflow 6d2abcc9 purchasing 10 Cars
-
-== APP == info: Microsoft.DurableTask.Client.Grpc.GrpcDurableTaskClient[40]
-== APP ==       Scheduling new OrderProcessingWorkflow orchestration with instance ID '6d2abcc9' and 47 bytes of input data.
-== APP == info: WorkflowConsoleApp.Activities.NotifyActivity[0]
-== APP ==       Received order 6d2abcc9 for 10 Cars at $15000
-== APP == info: WorkflowConsoleApp.Activities.ReserveInventoryActivity[0]
-== APP ==       Reserving inventory for order 6d2abcc9 of 10 Cars
-== APP == info: WorkflowConsoleApp.Activities.ReserveInventoryActivity[0]
-== APP ==       There are: 100, Cars available for purchase
-
-== APP == Your workflow has started. Here is the status of the workflow: Dapr.Workflow.WorkflowState
-
-== APP == info: WorkflowConsoleApp.Activities.ProcessPaymentActivity[0]
-== APP ==       Processing payment: 6d2abcc9 for 10 Cars at $15000
-== APP == info: WorkflowConsoleApp.Activities.ProcessPaymentActivity[0]
-== APP ==       Payment for request ID '6d2abcc9' processed successfully
-== APP == info: WorkflowConsoleApp.Activities.UpdateInventoryActivity[0]
-== APP ==       Checking Inventory for: Order# 6d2abcc9 for 10 Cars
-== APP == info: WorkflowConsoleApp.Activities.UpdateInventoryActivity[0]
-== APP ==       There are now: 90 Cars left in stock
-== APP == info: WorkflowConsoleApp.Activities.NotifyActivity[0]
-== APP ==       Order 6d2abcc9 has completed!
-
-== APP == Workflow Status: Completed
+== APP - order-processor == Starting workflow 898fd553 purchasing 10 Cars
+
+== APP - order-processor == info: Microsoft.DurableTask.Client.Grpc.GrpcDurableTaskClient[42]
+== APP - order-processor == Your workflow has started. Here is the status of the workflow: Running
+== APP - order-processor == info: WorkflowConsoleApp.Activities.NotifyActivity[1985924262]
+== APP - order-processor == info: WorkflowConsoleApp.Activities.NotifyActivity[1985924262]
+== APP - order-processor ==       Presenting notification Notification { Message = Received order 898fd553 for 10 Cars at $15000 }
+== APP - order-processor == info: Microsoft.DurableTask.Client.Grpc.GrpcDurableTaskClient[43]
+== APP - order-processor ==       Waiting for instance '898fd553' to complete, fail, or terminate.
+== APP - order-processor == info: WorkflowConsoleApp.Workflows.OrderProcessingWorkflow[2013970020]
+== APP - order-processor ==       Received request ID '898fd553' for 10 Cars at $15000
+== APP - order-processor == info: WorkflowConsoleApp.Activities.ReserveInventoryActivity[1988035937]
+== APP - order-processor ==       Reserving inventory for order request ID '898fd553' of 10 Cars
+== APP - order-processor == info: WorkflowConsoleApp.Activities.ReserveInventoryActivity[1130866279]
+== APP - order-processor ==       There are: 10 Cars available for purchase
+== APP - order-processor == info: WorkflowConsoleApp.Workflows.OrderProcessingWorkflow[1162731597]
+== APP - order-processor ==       Checked inventory for request ID 'InventoryRequest { RequestId = 898fd553, ItemName = Cars, Quantity = 10 }'
+== APP - order-processor == info: WorkflowConsoleApp.Activities.ProcessPaymentActivity[340284070]
+== APP - order-processor ==       Processing payment: request ID '898fd553' for 10 Cars at $15000
+== APP - order-processor == info: WorkflowConsoleApp.Activities.ProcessPaymentActivity[1851315765]
+== APP - order-processor ==       Payment for request ID '898fd553' processed successfully
+== APP - order-processor == info: WorkflowConsoleApp.Workflows.OrderProcessingWorkflow[340284070]
+== APP - order-processor ==       Processed payment request as there's sufficient inventory to proceed: PaymentRequest { RequestId = 898fd553, ItemBeingPurchased = Cars, Amount = 10, Currency = 15000 }
+== APP - order-processor == info: WorkflowConsoleApp.Activities.UpdateInventoryActivity[2144991393]
+== APP - order-processor ==       Checking inventory for request ID '898fd553' for 10 Cars
+== APP - order-processor == info: WorkflowConsoleApp.Activities.UpdateInventoryActivity[1901852920]
+== APP - order-processor ==       There are now 90 Cars left in stock
+== APP - order-processor == info: WorkflowConsoleApp.Workflows.OrderProcessingWorkflow[96138418]
+== APP - order-processor ==       Updating available inventory for PaymentRequest { RequestId = 898fd553, ItemBeingPurchased = Cars, Amount = 10, Currency = 15000 }
+== APP - order-processor == info: WorkflowConsoleApp.Activities.NotifyActivity[1985924262]
+== APP - order-processor ==       Presenting notification Notification { Message = Order 898fd553 has completed! }
+== APP - order-processor == info: WorkflowConsoleApp.Workflows.OrderProcessingWorkflow[510392223]
+== APP - order-processor ==       Order 898fd553 has completed
+== APP - order-processor == Workflow Status: Completed
 ```
 
 
@@ -99,12 +108,12 @@ docker run -d -p 9411:9411 openzipkin/zipkin
 
 When you ran `dapr run --app-id order-processor dotnet run`
 
-1. A unique order ID for the workflow is generated (in the above example, `6d2abcc9`) and the workflow is scheduled.
+1. A unique order ID for the workflow is generated (in the above example, `898fd553`) and the workflow is scheduled.
 2. The `NotifyActivity` workflow activity sends a notification saying an order for 10 cars has been received.
 3. The `ReserveInventoryActivity` workflow activity checks the inventory data, determines if you can supply the ordered item, and responds with the number of cars in stock.
 4. Your workflow starts and notifies you of its status.
-5. The `ProcessPaymentActivity` workflow activity begins processing payment for order `6d2abcc9` and confirms if successful.
+5. The `ProcessPaymentActivity` workflow activity begins processing payment for order `898fd553` and confirms if successful.
 6. The `UpdateInventoryActivity` workflow activity updates the inventory with the current available cars after the order has been processed.
-7. The `NotifyActivity` workflow activity sends a notification saying that order `6d2abcc9` has completed.
+7. The `NotifyActivity` workflow activity sends a notification saying that order `898fd553` has completed.
 8. The workflow terminates as completed.
 
diff --git a/workflows/csharp/sdk/order-processor/Activities/NotifyActivity.cs b/workflows/csharp/sdk/order-processor/Activities/NotifyActivity.cs
index 947450325..f100909bb 100644
--- a/workflows/csharp/sdk/order-processor/Activities/NotifyActivity.cs
+++ b/workflows/csharp/sdk/order-processor/Activities/NotifyActivity.cs
@@ -1,25 +1,19 @@
-namespace WorkflowConsoleApp.Activities
-{
-    using System.Threading.Tasks;
-    using Dapr.Workflow;
-    using Microsoft.Extensions.Logging;
+namespace WorkflowConsoleApp.Activities;
 
-    record Notification(string Message);
+using System.Threading.Tasks;
+using Dapr.Workflow;
+using Microsoft.Extensions.Logging;
 
-    class NotifyActivity : WorkflowActivity<Notification, object>
+internal sealed partial class NotifyActivity(ILogger<NotifyActivity> logger) : WorkflowActivity<Notification, object?>
+{
+    public override Task<object?> RunAsync(WorkflowActivityContext context, Notification notification)
     {
-        readonly ILogger logger;
-
-        public NotifyActivity(ILoggerFactory loggerFactory)
-        {
-            this.logger = loggerFactory.CreateLogger<NotifyActivity>();
-        }
-
-        public override Task<object> RunAsync(WorkflowActivityContext context, Notification notification)
-        {
-            this.logger.LogInformation(notification.Message);
-
-            return Task.FromResult<object>(null);
-        }
+        LogNotification(logger, notification);
+        return Task.FromResult<object?>(null);
     }
+    
+    [LoggerMessage(LogLevel.Information, "Presenting notification {notification}")]
+    static partial void LogNotification(ILogger logger, Notification notification);
 }
+
+internal sealed record Notification(string Message);
\ No newline at end of file
diff --git a/workflows/csharp/sdk/order-processor/Activities/ProcessPaymentActivity.cs b/workflows/csharp/sdk/order-processor/Activities/ProcessPaymentActivity.cs
index 0f14d37ef..004dca50e 100644
--- a/workflows/csharp/sdk/order-processor/Activities/ProcessPaymentActivity.cs
+++ b/workflows/csharp/sdk/order-processor/Activities/ProcessPaymentActivity.cs
@@ -1,40 +1,28 @@
-namespace WorkflowConsoleApp.Activities
-{
-    using System.Threading.Tasks;
-    using Dapr.Client;
-    using Dapr.Workflow;
-    using Microsoft.Extensions.Logging;
-    using WorkflowConsoleApp.Models;
-    using System;
+namespace WorkflowConsoleApp.Activities;
 
-    class ProcessPaymentActivity : WorkflowActivity<PaymentRequest, object>
-    {
-        readonly ILogger logger;
-        readonly DaprClient client;
+using System.Threading.Tasks;
+using Dapr.Client;
+using Dapr.Workflow;
+using Microsoft.Extensions.Logging;
+using Models;
+using System;
 
-        public ProcessPaymentActivity(ILoggerFactory loggerFactory, DaprClient client)
-        {
-            this.logger = loggerFactory.CreateLogger<ProcessPaymentActivity>();
-            this.client = client;
-        }
+internal sealed partial class ProcessPaymentActivity(ILogger<ProcessPaymentActivity> logger) : WorkflowActivity<PaymentRequest, object?>
+{
+    public override async Task<object?> RunAsync(WorkflowActivityContext context, PaymentRequest req)
+    {
+        LogPaymentProcessing(logger, req.RequestId, req.Amount, req.ItemBeingPurchased, req.Currency);
 
-        public override async Task<object> RunAsync(WorkflowActivityContext context, PaymentRequest req)
-        {
-            this.logger.LogInformation(
-                "Processing payment: {requestId} for {amount} {item} at ${currency}",
-                req.RequestId,
-                req.Amount,
-                req.ItemBeingPruchased,
-                req.Currency);
+        // Simulate slow processing
+        await Task.Delay(TimeSpan.FromSeconds(7));
 
-            // Simulate slow processing
-            await Task.Delay(TimeSpan.FromSeconds(7));
+        LogSuccessfulPayment(logger, req.RequestId);
+        return null;
+    }
 
-            this.logger.LogInformation(
-                "Payment for request ID '{requestId}' processed successfully",
-                req.RequestId);
+    [LoggerMessage(LogLevel.Information, "Processing payment: request ID '{requestId}' for {amount} {itemBeingPurchased} at ${currency}")]
+    static partial void LogPaymentProcessing(ILogger logger, string requestId, int amount, string itemBeingPurchased, double currency);
 
-            return null;
-        }
-    }
-}
+    [LoggerMessage(LogLevel.Information, "Payment for request ID '{requestId}' processed successfully")]
+    static partial void LogSuccessfulPayment(ILogger logger, string requestId);
+}
\ No newline at end of file
diff --git a/workflows/csharp/sdk/order-processor/Activities/ReserveInventoryActivity.cs b/workflows/csharp/sdk/order-processor/Activities/ReserveInventoryActivity.cs
index d620ef56f..1d797002b 100644
--- a/workflows/csharp/sdk/order-processor/Activities/ReserveInventoryActivity.cs
+++ b/workflows/csharp/sdk/order-processor/Activities/ReserveInventoryActivity.cs
@@ -1,62 +1,55 @@
-namespace WorkflowConsoleApp.Activities
+namespace WorkflowConsoleApp.Activities;
+
+using System.Threading.Tasks;
+using Dapr.Client;
+using Dapr.Workflow;
+using Microsoft.Extensions.Logging;
+using Models;
+using System;
+
+internal sealed partial class ReserveInventoryActivity(ILogger<ReserveInventoryActivity> logger, DaprClient daprClient) : WorkflowActivity<InventoryRequest, InventoryResult>
 {
-    using System.Threading.Tasks;
-    using Dapr.Client;
-    using Dapr.Workflow;
-    using Microsoft.Extensions.Logging;
-    using WorkflowConsoleApp.Models;
-    using System;
-
-    class ReserveInventoryActivity : WorkflowActivity<InventoryRequest, InventoryResult>
+    private const string StoreName = "statestore";
+
+    public override async Task<InventoryResult> RunAsync(WorkflowActivityContext context, InventoryRequest req)
     {
-        readonly ILogger logger;
-        readonly DaprClient client;
-        static readonly string storeName = "statestore";
+        LogReserveInventory(logger, req.RequestId, req.Quantity, req.ItemName);
 
-        public ReserveInventoryActivity(ILoggerFactory loggerFactory, DaprClient client)
+        // Ensure that the store has items
+        var (orderResult, _) = await daprClient.GetStateAndETagAsync<OrderPayload>(StoreName, req.ItemName);
+
+        // Catch for the case where the statestore isn't setup
+        if (orderResult is null)
         {
-            this.logger = loggerFactory.CreateLogger<ReserveInventoryActivity>();
-            this.client = client;
+            // Not enough items.
+            LogStateNotFound(logger, req.RequestId, req.ItemName);
+            return new InventoryResult(false, null);
         }
 
-        public override async Task<InventoryResult> RunAsync(WorkflowActivityContext context, InventoryRequest req)
+        // See if there are enough items to purchase
+        if (orderResult.Quantity >= req.Quantity)
         {
-            this.logger.LogInformation(
-                "Reserving inventory for order {requestId} of {quantity} {name}",
-                req.RequestId,
-                req.Quantity,
-                req.ItemName);
-
-            OrderPayload orderResponse;
-            string key;
-
-            // Ensure that the store has items
-            (orderResponse, key) = await client.GetStateAndETagAsync<OrderPayload>(storeName, req.ItemName);
-
-            // Catch for the case where the statestore isn't setup
-            if (orderResponse == null)
-            {
-                // Not enough items.
-                return new InventoryResult(false, orderResponse);
-            }
-
-            this.logger.LogInformation(
-                "There are: {requestId}, {name} available for purchase",
-                orderResponse.Quantity,
-                orderResponse.Name);
-
-            // See if there're enough items to purchase
-            if (orderResponse.Quantity >= req.Quantity)
-            {
-                // Simulate slow processing
-                await Task.Delay(TimeSpan.FromSeconds(2));
-
-                return new InventoryResult(true, orderResponse);
-            }
-
-            // Not enough items.
-            return new InventoryResult(false, orderResponse);
+            // Simulate slow processing
+            await Task.Delay(TimeSpan.FromSeconds(2));
 
+            LogSufficientInventory(logger, req.Quantity, req.ItemName);
+            return new InventoryResult(true, orderResult);
         }
+
+        // Not enough items.
+        LogInsufficientInventory(logger, req.RequestId, req.ItemName);
+        return new InventoryResult(false, orderResult);
     }
-}
+
+    [LoggerMessage(LogLevel.Information, "Reserving inventory for order request ID '{requestId}' of {quantity} {name}")]
+    static partial void LogReserveInventory(ILogger logger, string requestId, int quantity, string name);
+
+    [LoggerMessage(LogLevel.Warning, "Unable to locate an order result for request ID '{requestId}' for the indicated item {itemName} in the state store")]
+    static partial void LogStateNotFound(ILogger logger, string requestId, string itemName);
+
+    [LoggerMessage(LogLevel.Information, "There are: {quantity} {name} available for purchase")]
+    static partial void LogSufficientInventory(ILogger logger, int quantity, string name);
+
+    [LoggerMessage(LogLevel.Warning, "There is insufficient inventory available for order request ID '{requestId}' for the item {itemName}")]
+    static partial void LogInsufficientInventory(ILogger logger, string requestId, string itemName);
+}
\ No newline at end of file
diff --git a/workflows/csharp/sdk/order-processor/Activities/UpdateInventoryActivity.cs b/workflows/csharp/sdk/order-processor/Activities/UpdateInventoryActivity.cs
index bbd01606f..8f7dd4a61 100644
--- a/workflows/csharp/sdk/order-processor/Activities/UpdateInventoryActivity.cs
+++ b/workflows/csharp/sdk/order-processor/Activities/UpdateInventoryActivity.cs
@@ -1,52 +1,46 @@
-namespace WorkflowConsoleApp.Activities
+namespace WorkflowConsoleApp.Activities;
+
+using System.Threading.Tasks;
+using Dapr.Client;
+using Dapr.Workflow;
+using Models;
+using Microsoft.Extensions.Logging;
+using System;
+
+internal sealed partial class UpdateInventoryActivity(ILogger<UpdateInventoryActivity> logger, DaprClient daprClient) : WorkflowActivity<PaymentRequest, object?>
 {
-    using System.Threading.Tasks;
-    using Dapr.Client;
-    using Dapr.Workflow;
-    using WorkflowConsoleApp.Models;
-    using Microsoft.Extensions.Logging;
-    using System;
-
-    class UpdateInventoryActivity : WorkflowActivity<PaymentRequest, Object>
+    private const string StoreName = "statestore";
+
+    public override async Task<object?> RunAsync(WorkflowActivityContext context, PaymentRequest req)
     {
-        static readonly string storeName = "statestore";
-        readonly ILogger logger;
-        readonly DaprClient client;
+        LogCheckingInventory(logger, req.RequestId, req.ItemBeingPurchased, req.Amount);
 
-        public UpdateInventoryActivity(ILoggerFactory loggerFactory, DaprClient client)
-        {
-            this.logger = loggerFactory.CreateLogger<UpdateInventoryActivity>();
-            this.client = client;
-        }
+        // Simulate slow processing
+        await Task.Delay(TimeSpan.FromSeconds(5));
 
-        public override async Task<Object> RunAsync(WorkflowActivityContext context, PaymentRequest req)
-        {
-            this.logger.LogInformation(
-                "Checking Inventory for: Order# {requestId} for {amount} {item}",
-                req.RequestId,
-                req.Amount,
-                req.ItemBeingPruchased);
-
-            // Simulate slow processing
-            await Task.Delay(TimeSpan.FromSeconds(5));
-
-            // Determine if there are enough Items for purchase
-            var (original, originalETag) = await client.GetStateAndETagAsync<OrderPayload>(storeName, req.ItemBeingPruchased);
-            int newQuantity = original.Quantity - req.Amount;
+        // Determine if there are enough Items for purchase
+        var (original, _) = await daprClient.GetStateAndETagAsync<OrderPayload>(StoreName, req.ItemBeingPurchased);
+        var newQuantity = original.Quantity - req.Amount;
             
-            if (newQuantity < 0)
-            {
-                this.logger.LogInformation(
-                    "Payment for request ID '{requestId}' could not be processed. Insufficient inventory.",
-                    req.RequestId);
-                throw new InvalidOperationException();
-            }
-
-            // Update the statestore with the new amount of paper clips
-            await client.SaveStateAsync<OrderPayload>(storeName, req.ItemBeingPruchased,  new OrderPayload(Name: req.ItemBeingPruchased, TotalCost: req.Currency, Quantity: newQuantity));
-            this.logger.LogInformation($"There are now: {newQuantity} {original.Name} left in stock");
-
-            return null;
+        if (newQuantity < 0)
+        {
+            LogInsufficientInventory(logger, req.RequestId);
+            throw new InvalidOperationException();
         }
+
+        // Update the statestore with the new amount of paper clips
+        await daprClient.SaveStateAsync(StoreName, req.ItemBeingPurchased,  new OrderPayload(Name: req.ItemBeingPurchased, TotalCost: req.Currency, Quantity: newQuantity));
+        LogUpdatedInventory(logger, newQuantity, original.Name);
+
+        return null;
     }
-}
+
+    [LoggerMessage(LogLevel.Information, "Checking inventory for request ID '{requestId}' for {quantity} {item}")]
+    static partial void LogCheckingInventory(ILogger logger, string requestId, string item, int quantity);
+
+    [LoggerMessage(LogLevel.Warning, "Payment for request ID '{requestId}' could not be processed as there's insufficient inventory available")]
+    static partial void LogInsufficientInventory(ILogger logger, string requestId);
+
+    [LoggerMessage(LogLevel.Information, "There are now {newQuantity} {itemName} left in stock")]
+    static partial void LogUpdatedInventory(ILogger logger, int newQuantity, string itemName);
+}
\ No newline at end of file
diff --git a/workflows/csharp/sdk/order-processor/Models.cs b/workflows/csharp/sdk/order-processor/Models.cs
index 82bf71931..772c18e5c 100644
--- a/workflows/csharp/sdk/order-processor/Models.cs
+++ b/workflows/csharp/sdk/order-processor/Models.cs
@@ -1,9 +1,7 @@
-namespace WorkflowConsoleApp.Models 
-{
-    record OrderPayload(string Name, double TotalCost, int Quantity = 1);
-    record InventoryRequest(string RequestId, string ItemName, int Quantity);
-    record InventoryResult(bool Success, OrderPayload orderPayload);
-    record PaymentRequest(string RequestId, string ItemBeingPruchased, int Amount, double Currency);
-    record OrderResult(bool Processed);
-    record InventoryItem(string Name, double TotalCost, int Quantity);
-}
\ No newline at end of file
+namespace WorkflowConsoleApp.Models;
+
+internal sealed record OrderPayload(string Name, double TotalCost, int Quantity = 1);
+internal sealed record InventoryRequest(string RequestId, string ItemName, int Quantity);
+internal sealed record InventoryResult(bool Success, OrderPayload? OrderPayload);
+internal sealed record PaymentRequest(string RequestId, string ItemBeingPurchased, int Amount, double Currency);
+internal sealed record OrderResult(bool Processed);
\ No newline at end of file
diff --git a/workflows/csharp/sdk/order-processor/Program.cs b/workflows/csharp/sdk/order-processor/Program.cs
index 68711c1e0..8b7cff841 100644
--- a/workflows/csharp/sdk/order-processor/Program.cs
+++ b/workflows/csharp/sdk/order-processor/Program.cs
@@ -2,17 +2,16 @@
 using Dapr.Workflow;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.DependencyInjection;
-using System;
 using WorkflowConsoleApp.Activities;
 using WorkflowConsoleApp.Models;
 using WorkflowConsoleApp.Workflows;
 
-const string StoreName = "statestore";
-const string DaprWorkflowComponent = "dapr";
+const string storeName = "statestore";
 
 // The workflow host is a background service that connects to the sidecar over gRPC
 var builder = Host.CreateDefaultBuilder(args).ConfigureServices(services =>
 {
+    services.AddDaprClient();
     services.AddDaprWorkflow(options =>
     {
         // Note that it's also possible to register a lambda function as the workflow
@@ -31,23 +30,22 @@
 using var host = builder.Build();
 host.Start();
 
-using var daprClient = new DaprClientBuilder().Build();
-
-DaprWorkflowClient workflowClient = host.Services.GetRequiredService<DaprWorkflowClient>();
+var daprClient = host.Services.GetRequiredService<DaprClient>();
+var workflowClient = host.Services.GetRequiredService<DaprWorkflowClient>();
 
 // Generate a unique ID for the workflow
-string orderId = Guid.NewGuid().ToString()[..8];
-string itemToPurchase = "Cars";
-int ammountToPurchase = 10;
+var orderId = Guid.NewGuid().ToString()[..8];
+const string itemToPurchase = "Cars";
+const int amountToPurchase = 10;
 
 // Populate the store with items
 RestockInventory(itemToPurchase);
 
 // Construct the order
-OrderPayload orderInfo = new OrderPayload(itemToPurchase, 15000, ammountToPurchase);
+var orderInfo = new OrderPayload(itemToPurchase, 15000, amountToPurchase);
 
 // Start the workflow
-Console.WriteLine("Starting workflow {0} purchasing {1} {2}", orderId, ammountToPurchase, itemToPurchase);
+Console.WriteLine($"Starting workflow {orderId} purchasing {amountToPurchase} {itemToPurchase}");
 
 await workflowClient.ScheduleNewWorkflowAsync(
     name: nameof(OrderProcessingWorkflow),
@@ -55,19 +53,19 @@ await workflowClient.ScheduleNewWorkflowAsync(
     input: orderInfo);
 
 // Wait for the workflow to start and confirm the input
-WorkflowState state = await workflowClient.WaitForWorkflowStartAsync(
+var state = await workflowClient.WaitForWorkflowStartAsync(
     instanceId: orderId);
 
-Console.WriteLine("Your workflow has started. Here is the status of the workflow: {0}", Enum.GetName(typeof(WorkflowRuntimeStatus), state.RuntimeStatus));
+Console.WriteLine($"Your workflow has started. Here is the status of the workflow: {Enum.GetName(typeof(WorkflowRuntimeStatus), state.RuntimeStatus)}");
 
 // Wait for the workflow to complete
 state = await workflowClient.WaitForWorkflowCompletionAsync(
     instanceId: orderId);
 
 Console.WriteLine("Workflow Status: {0}", Enum.GetName(typeof(WorkflowRuntimeStatus), state.RuntimeStatus));
+return;
 
 void RestockInventory(string itemToPurchase)
 {
-    daprClient.SaveStateAsync<OrderPayload>(StoreName, itemToPurchase, new OrderPayload(Name: itemToPurchase, TotalCost: 15000, Quantity: 100));
-    return;
+    daprClient.SaveStateAsync(storeName, itemToPurchase, new OrderPayload(Name: itemToPurchase, TotalCost: 15000, Quantity: 100));
 }
diff --git a/workflows/csharp/sdk/order-processor/WorkflowConsoleApp.csproj b/workflows/csharp/sdk/order-processor/WorkflowConsoleApp.csproj
index e58fe9f8c..b3fc4b311 100644
--- a/workflows/csharp/sdk/order-processor/WorkflowConsoleApp.csproj
+++ b/workflows/csharp/sdk/order-processor/WorkflowConsoleApp.csproj
@@ -2,6 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
+    <Nullable>enable</Nullable>
     <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <LangVersion>latest</LangVersion>
@@ -9,8 +10,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Dapr.AspNetCore" Version="1.14.*-*" />
-    <PackageReference Include="Dapr.Workflow" Version="1.14.*-*" />
+    <PackageReference Include="Dapr.Workflow" Version="1.15.0-rc02" />
   </ItemGroup>
 
 </Project>
diff --git a/workflows/csharp/sdk/order-processor/Workflows/OrderProcessingWorkflow.cs b/workflows/csharp/sdk/order-processor/Workflows/OrderProcessingWorkflow.cs
index 68de9b4fd..c425b8c94 100644
--- a/workflows/csharp/sdk/order-processor/Workflows/OrderProcessingWorkflow.cs
+++ b/workflows/csharp/sdk/order-processor/Workflows/OrderProcessingWorkflow.cs
@@ -1,67 +1,87 @@
-namespace WorkflowConsoleApp.Workflows
-{
-    using System.Threading.Tasks;
-    using Dapr.Workflow;
-    using DurableTask.Core.Exceptions;
-    using WorkflowConsoleApp.Activities;
-    using WorkflowConsoleApp.Models;
+namespace WorkflowConsoleApp.Workflows;
 
-    class OrderProcessingWorkflow : Workflow<OrderPayload, OrderResult>
-    {
-        public override async Task<OrderResult> RunAsync(WorkflowContext context, OrderPayload order)
-        {
-            string orderId = context.InstanceId;
+using Microsoft.Extensions.Logging;
+using System.Threading.Tasks;
+using Dapr.Workflow;
+using DurableTask.Core.Exceptions;
+using Activities;
+using Models;
 
-            // Notify the user that an order has come through
-            await context.CallActivityAsync(
-                nameof(NotifyActivity),
-                new Notification($"Received order {orderId} for {order.Quantity} {order.Name} at ${order.TotalCost}"));
+internal sealed partial class OrderProcessingWorkflow : Workflow<OrderPayload, OrderResult>
+{
+    public override async Task<OrderResult> RunAsync(WorkflowContext context, OrderPayload order)
+    {
+        var logger = context.CreateReplaySafeLogger<OrderProcessingWorkflow>();
+        var orderId = context.InstanceId;
 
-            string requestId = context.InstanceId;
+        // Notify the user that an order has come through
+        await context.CallActivityAsync(nameof(NotifyActivity),
+            new Notification($"Received order {orderId} for {order.Quantity} {order.Name} at ${order.TotalCost}"));
+        LogOrderReceived(logger, orderId, order.Quantity, order.Name, order.TotalCost);
 
-            // Determine if there is enough of the item available for purchase by checking the inventory
-            InventoryResult result = await context.CallActivityAsync<InventoryResult>(
-                nameof(ReserveInventoryActivity),
-                new InventoryRequest(RequestId: orderId, order.Name, order.Quantity));
+        // Determine if there is enough of the item available for purchase by checking the inventory
+        var inventoryRequest = new InventoryRequest(RequestId: orderId, order.Name, order.Quantity);
+        var result = await context.CallActivityAsync<InventoryResult>(
+            nameof(ReserveInventoryActivity), inventoryRequest);
+        LogCheckInventory(logger, inventoryRequest);
             
-            // If there is insufficient inventory, fail and let the user know 
-            if (!result.Success)
-            {
-                // End the workflow here since we don't have sufficient inventory
-                await context.CallActivityAsync(
-                    nameof(NotifyActivity),
-                    new Notification($"Insufficient inventory for {order.Name}"));
-                return new OrderResult(Processed: false);
-            }
+        // If there is insufficient inventory, fail and let the user know 
+        if (!result.Success)
+        {
+            // End the workflow here since we don't have sufficient inventory
+            await context.CallActivityAsync(nameof(NotifyActivity),
+                new Notification($"Insufficient inventory for {order.Name}"));
+            LogInsufficientInventory(logger, order.Name);
+            return new OrderResult(Processed: false);
+        }
 
-            // There is enough inventory available so the user can purchase the item(s). Process their payment
-            await context.CallActivityAsync(
-                nameof(ProcessPaymentActivity),
-                new PaymentRequest(RequestId: orderId, order.Name, order.Quantity, order.TotalCost));
+        // There is enough inventory available so the user can purchase the item(s). Process their payment
+        var processPaymentRequest = new PaymentRequest(RequestId: orderId, order.Name, order.Quantity, order.TotalCost);
+        await context.CallActivityAsync(nameof(ProcessPaymentActivity),processPaymentRequest);
+        LogPaymentProcessing(logger, processPaymentRequest);
 
-            try
-            {
-                // There is enough inventory available so the user can purchase the item(s). Process their payment
-                await context.CallActivityAsync(
-                    nameof(UpdateInventoryActivity),
-                    new PaymentRequest(RequestId: orderId, order.Name, order.Quantity, order.TotalCost));                
-            }
-            catch (TaskFailedException)
-            {
-                // Let them know their payment was processed
-                await context.CallActivityAsync(
-                    nameof(NotifyActivity),
-                    new Notification($"Order {orderId} Failed! You are now getting a refund"));
-                return new OrderResult(Processed: false);
-            }
+        try
+        {
+            // Update the available inventory
+            var paymentRequest = new PaymentRequest(RequestId: orderId, order.Name, order.Quantity, order.TotalCost); 
+            await context.CallActivityAsync(nameof(UpdateInventoryActivity), paymentRequest);
+            LogInventoryUpdate(logger, paymentRequest);
+        }
+        catch (TaskFailedException)
+        {
+            // Let them know their payment was processed, but there's insufficient inventory, so they're getting a refund
+            await context.CallActivityAsync(nameof(NotifyActivity),
+                new Notification($"Order {orderId} Failed! You are now getting a refund"));
+            LogRefund(logger, orderId);
+            return new OrderResult(Processed: false);
+        }
 
-            // Let them know their payment was processed
-            await context.CallActivityAsync(
-                nameof(NotifyActivity),
-                new Notification($"Order {orderId} has completed!"));
+        // Let them know their payment was processed
+        await context.CallActivityAsync(nameof(NotifyActivity), new Notification($"Order {orderId} has completed!"));
+        LogSuccessfulOrder(logger, orderId);
 
-            // End the workflow with a success result
-            return new OrderResult(Processed: true);
-        }
+        // End the workflow with a success result
+        return new OrderResult(Processed: true);
     }
-}
+
+    [LoggerMessage(LogLevel.Information, "Received request ID '{request}' for {quantity} {name} at ${totalCost}")]
+    static partial void LogOrderReceived(ILogger logger, string request, int quantity, string name, double totalCost);
+    
+    [LoggerMessage(LogLevel.Information, "Checked inventory for request ID '{request}'")]
+    static partial void LogCheckInventory(ILogger logger, InventoryRequest request);
+    
+    [LoggerMessage(LogLevel.Information, "Insufficient inventory for order {orderName}")]
+    static partial void LogInsufficientInventory(ILogger logger, string orderName);
+    
+    [LoggerMessage(LogLevel.Information, "Processed payment request as there's sufficient inventory to proceed: {request}")]
+    static partial void LogPaymentProcessing(ILogger logger, PaymentRequest request);
+
+    [LoggerMessage(LogLevel.Information, "Updating available inventory for {request}")]
+    static partial void LogInventoryUpdate(ILogger logger, PaymentRequest request);
+
+    [LoggerMessage(LogLevel.Information, "Order {orderId} failed due to insufficient inventory - processing refund")]
+    static partial void LogRefund(ILogger logger, string orderId);
+
+    [LoggerMessage(LogLevel.Information, "Order {orderId} has completed")]
+    static partial void LogSuccessfulOrder(ILogger logger, string orderId);
+}
\ No newline at end of file