Potential File Structure for Complex Dynamic Workloads with Separation of Concerns, Weighted Scenarios & Conditional Execution

[CMorrisonJHA]

[1/22/2026: I have slightly refactored this post to reflect current updates to my approach.]

Many of the load test scenarios my organization wants be to run are complex, involving many different types of requests all running at various rates.
This post documents one way to achieve this in NBomber.

My basic idea here is to keep each scenario in a separate C# file, and separate the load test registration from the scenario (request) flows.

This separation of concerns makes for shorter C# files, and follows the pattern of classic load testing tools such as LoadRunner and Visual Studio where the load test with User/Thread specifications is in one file (e.g., xxx.loadtest) and the "script" or set of requests in the another (e.g., Flow01.webtest).

The approach below uses NBomber's "Run Multiple Scenarios in Parallel" model. But I have added a little code to assign users (threads) to each of the parallel-running scenarios in a fixed ratio. (see the dictionary at the top of the LoadTest class).

I think the same thing could be achieved by NBomber's built in "Scenario Distribution by Weight Probability" approach. (And I might switch my example below to using Distribution by Weight Probability. However, the code below makes talking about users easier. In much of my load testing experience, it is easier to talk to management about "users," rather than requests per second. The approach below will make a little more sense when I add pacing to the example.

Features of this Approach

• Follows good coding practices of separation of concerns. Each scenario is a in separate, shorter, easier-to-work-with file.
• Multiple opportunities, at different levels, to proportion (or distribute) the requests, making it easier to emulate peak Production loads captured from monitoring tool such as Application Dynamics, Splunk, Application Insights, and Omniture (now Adobe Analytics).
  • The LoadTest class illustrates a concise way to distribute or proportion requests at scenario level. (I have a little more work to do here around pacing and Little's Law, so I will update this post in the future.) Structuring the scenario registration this way makes it easier group scenarios around different workflows or user roles. For instance, administrative users typically have a different path through an application than do normal users. (For instance in a banking application normal users are making deposits, but administrators are making roll-up reports). Structuring the workflows in this way allows the LoadTest class to assigns uses (threads) to each workflow (giving lower numbers of threads to workflows performed by administrators for instance).
  • We can also proportion or distribute individual requests within a scenario by simply using IF statements (see Scenario 01, below).
    -DataFeeds are declared in the LoadTest class. I can do this because in my application scenarios can use the same data. I can instantiate the data feeds in the LoadTest class, and then just call for a new user at the top of each scenario before I do an authenticate request. In the example below the scenario has the responsibility of instantiating the datafeed, but datafeeds are shared resource of the entire test. (Variations are possible here.)
• Note that the example below is set up for a capacity test, so each scenario is using NBomber's "Simulation.RampingConstant" approach. Event though we are ramping up users, the dictionary at the top of the load test class keeps the threads proportion in same ratios, even though the threads are increasing.

File 01: The Load Test Class

  [TestClass]
 public class CapacityTestWithInitialAndMaxUsers
 {
     private readonly TimescaleDbSink _timescaleDbSink = new();

     [TestMethod]
     public void LT_HiVolume_Capacity()
     {
         int initialUsers = 40;
         int maxUsers = 100; // Change this for capacity tests. The dictionary keeps ratios of users assigned to the load tests the same.
         int durationInMinutes = 1;

         var ratios = new Dictionary<string, double>
         {
             { "Register", 0.43 },       // 43%
             { "Approval", 0.09 },         // 9%
             { "DepositCheck", 0.42 },     // 42%
             { "ViewDepositHistory", 0.15 } // 15%
         };

         // Distribute users for both initial and max
         var initialUserDistribution = DistributeUsers(initialUsers, ratios);
         var maxUserDistribution = DistributeUsers(maxUsers, ratios);

         int depositInitCopies = initialUserDistribution["DepositCheck"];
         int approvalInitCopies = initialUserDistribution["Approval"];     
         int enrollmentInitCopies = initialUserDistribution["RegisterCustomer"];
         int viewInitCopies = initialUserDistribution["ViewDepositHistory"]; // Omitted for post berevity

         int depositMaxCopies = maxUserDistribution["DepositCheck"];
         int approvalMaxCopies = maxUserDistribution["Approval"];
         int enrollmentMaxCopies = maxUserDistribution["RegisterCustomer"];
         int viewMaxCopies = maxUserDistribution["ViewDepositHistory"]; // Omitted for post berevity

         var depositScenario = DepositCheckScenario.Create(depositInitCopies, depositMaxCopies, targetIterationsPerHour:135, durationInMinutes);
         var approvalScenario = ApproveCustomerScenario.Create(approvalInitCopies, approvalMaxCopies, targetIterationsPerHour:30, durationInMinutes);
         var depositCheckScenario = RegisterCustomerScenario.Create(registerInitCopies,registerMaxreopies, targetIterationsPerHour: 135, durationInMinutes);
         var viewDepositHistoryScenario = ViewDepositHistoryScenario.Create(viewInitCopies, viewMaxCopies, targetIterationsPerHour: 15, durationInMinutes);

         NBomberRunner
             .RegisterScenarios(enrollmentScenario, approvalScenario, viewDepositHistoryScenario,)
             .LoadInfraConfig("infra-config.json")
             .WithReportingSinks(_timescaleDbSink)
             .WithTestName("HiVolumeCapacity")
             .Run();
     }

    // Helper method to distribute the threads among various load tests.
     private static Dictionary<string, int> DistributeUsers(int totalUsers, Dictionary<string, double> ratios)
     {
         return ratios.ToDictionary(
             kvp => kvp.Key,
             kvp => (int)(totalUsers * kvp.Value)
         );
     }
 }

Notice in the above that I am taking the number I got from Application Dynamics, the target transactions per hour, and passing it to a method which creates each load test for me. This main class, just registers the scenarios.

    /// <summary>
    /// Handle shared , data, and thinkTime initialization
	/// I have a fault-tolerant, exception handling client, which handles multiple threads. 
    /// </summary>
    public static class SharedResources
    {
        public static int thinkTimeBetweenSteps = 1000;

		// Note that multiple different kinds of clients can be declared here
        public static ServiceFactory RequestClient => _factories.Value.serviceXRequestFactory;   

		// Singleton Initialization of the service factory or factories.
		// Using "Lazy" is just a concise way of making singleton in C#.
        private static readonly Lazy<(serviceXRequestFactory serviceX)> _factories = new(() =>
        {
            try
            {
                var serviceXRequestFactory = new ServiceXRequestFactory();
                return (serviceXRequestFactory);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error initializing factories: {ex.Message}");
                throw;
            }
        });		

        private static IDataFeed<long>? _accountIdFeed;
        private static IDataFeed<RdaUser>? _usersFeed;

        public static IDataFeed<long> HBIDFeed => _hBIDFeed ?? throw new InvalidOperationException("HBIDFeed not initialized.");
        public static IDataFeed<RdaUser> UsersFeed => _usersFeed ?? throw new InvalidOperationException("UsersFeed not initialized.");

        public static void InitializeDataFeeds()
        {
            //  Account data feed
            var accountIDData = Data.LoadCsv<long>("./Data/Prod/AcctNums.csv");
            _hBIDFeed = DataFeed.Constant(hBIDData);

            // User data feed
            var UserData = Data.LoadCsv<RdaUser>("./Data/Prod/PerformanceTestUsers.csv");
            _usersFeed = DataFeed.Constant(RdaUserData);
        }
    }

File 02: Scenario 01

public static class DepositCheckScenario
{
   private static readonly Random _random = new Random();

   public static ScenarioProps Create(int initCopies, int maxCopies, int targetIterationsPerHour, int durationInMinutes)
   {     
       var paceTimeInSeconds = 30;
       DateTime? iterationStart = DateTime.UtcNow;

       // Calculate the target interval between iterations in milliseconds
       **double targetIntervalMs = 3600_000.0 / targetIterationsPerHour;**

       var scenario = NBomber.CSharp.Scenario.Create("LT_03_DepositCheck", async context =>
       {
            string? securityToken = null;
           long hbid = SharedResources.HBIDFeed.GetNextItem(context.ScenarioInfo);
           RdaUser user = SharedResources.UsersFeed.GetNextItem(context.ScenarioInfo);
           int thinkTimeBetweenSteps = SharedResources.thinkTimeBetweenSteps;

               var request01 = await NBomber.CSharp.Step.Run("01_Authenticate", context, async () =>
               {
                   var response = await Task.Run(() => SharedResources.RequestClient.Authenticate(user));
                   securityToken = response.AuthenticateResult.Credentials.SecurityToken;
                   StringAssert.Contains(response.AuthenticateResult.Result.ToString(), "Success");

                   await Task.Delay(thinkTimeBetweenSteps);
                   return NBomber.CSharp.Response.Ok();
               });

               string accountReference = string.Empty;
               var request02 = await NBomber.CSharp.Step.Run("02GetAccounts", context, async () =>
               {
                   var response = await Task.Run(() => SharedResources.RequestClient.GetAccounts(securityToken));
                   StringAssert.Contains(response.GetAccountsResult.Result.ToString(), "Success");

                   accountReference = response.GetAccountsResult.Accounts != null
                       && response.GetAccountsResult.Accounts.Length > 0
                       ? response.GetAccountsResult.Accounts[0].ReferenceId
                       : string.Empty;

                   await Task.Delay(thinkTimeBetweenSteps);
                   return NBomber.CSharp.Response.Ok();
               });            

           var request03 = await NBomber.CSharp.Step.Run("03_Logout", context, async () =>
           {
               var response = await Task.Run(() => SharedResources.RequestClient.Logout(securityToken));
               StringAssert.Contains(response.LogoutResult.Result.ToString(), "Success");

               await Task.Delay(thinkTimeBetweenSteps);
               return NBomber.CSharp.Response.Ok();
           });
     
       // If an iteration takes longer than the target interval, the next one starts immediately(no negative delay).
       // This approach is robust to variable response times and will "catch up" as much as possible if the system falls behind.
       // Calculate elapsed time and enforce dynamic pacing
           var elapsed = (DateTime.UtcNow - iterationStart!.Value).TotalMilliseconds;
           var remaining = targetIntervalMs - elapsed;
           if (remaining > 0)
           {
               await Task.Delay((int)remaining);
           }

           return NBomber.CSharp.Response.Ok();
       })
           .WithWarmUpDuration(TimeSpan.FromSeconds(5)) // gets rid of response time bump on the HTML chart.
           .WithLoadSimulations(
               Simulation.RampingConstant(copies: initCopies, during: TimeSpan.FromSeconds(3)),
               Simulation.RampingConstant(copies: maxCopies, during: TimeSpan.FromMinutes(durationInMinutes)))
           .WithInit(context =>
           {
               SharedResources.InitializeDataFeeds();

               return Task.CompletedTask;
           });

       return scenario;
   }
}
            

File 03: Scenario 02

    public static class RegisterCustomerScenario
    {
        private static readonly Random _random = new Random(); // used in conditional IF statement

     public static ScenarioProps Create(int initCopies, int maxCopies, int targetIterationsPerHour, int durationInMinutes)
    {    
       DateTime? iterationStart = null;
      // Calculate the target interval between iterations in milliseconds
      double targetIntervalMs = 3600_000.0 / targetIterationsPerHour;

            var scenario = Scenario.Create("RegisterCustomer", async context =>
            {            
                string securityToken = null;
               int thinkTimeBetweenSteps = MobileHiVolumeSharedResources.thinkTimeBetweenSteps;
                long accountId = SharedResources.accountIdFeed.GetNextItem(context.ScenarioInfo); 
                User user = SharedResources.UsersFeed.GetNextItem(context.ScenarioInfo);
		
                var request01 = await Step.Run("01_Authenticate", context, async () =>
                {
                   iterationStart = DateTime.UtcNow;
                    var response = await Task.Run(() => SharedResources.RequestClient.Authenticate(user));
                    StringAssert.Contains(response.AuthenticateResult.Result.ToString(), "Success");

                    securityToken = response.AuthenticateResult.Credentials.SecurityToken; // assign value from a response.

                    await Task.Delay(thinkTimeBetweenSteps);
                    return Response.Ok();
                });
    
		var request02 = await Step.Run("02_GetCustomers", context, async () =>
		{
			var response = await Task.Run(() => SharedResources.RequestClient.GetAccounts(accountId));
			StringAssert.Contains(response.GetAccountsResult.Result.ToString(), "Success");

			await Task.Delay(thinkTimeBetweenSteps);
			return Response.Ok();
		});                            
                              

               *var request03 = await Step.Run("03_Logout", context, async () =>
                {
                    var response = await Task.Run(() => SharedResources.RequestClient.Logout(securityToken));
                    StringAssert.Contains(response.LogoutResult.Result.ToString(), "Success");

                    await Task.Delay(thinkTimeBetweenSteps);
                    return Response.Ok();
                });
  
         // see note above about this code
          **var elapsed = (DateTime.UtcNow - iterationStart!.Value).TotalMilliseconds;
          var remaining = targetIntervalMs - elapsed;
          if (remaining > 0)
          {
              await Task.Delay((int)remaining);
          }**

          return NBomber.CSharp.Response.Ok();
      })
     .WithWarmUpDuration(TimeSpan.FromSeconds(5)) // gets rid of response time bump on the HTML chart.
          .WithLoadSimulations(
              Simulation.RampingConstant(copies: initCopies, during: TimeSpan.FromSeconds(3)),
              Simulation.RampingConstant(copies: maxCopies, during: TimeSpan.FromMinutes(durationInMinutes)))
          .WithInit(context =>
          {
              SharedResources.InitializeDataFeeds();

              return Task.CompletedTask;
          });

      return scenario;
  }
    }

File 04: Scenario 03

    public static class ApproveCustomerScenario
    {
        private static readonly Random _random = new Random(); // used in conditional IF statement

        public static ScenarioProps Create()
        {
            var scenario = Scenario.Create("ApproveCustomer", async context =>
            {
                long accountId = SharedResources.accountIdFeed.GetNextItem(context.ScenarioInfo); 
                User user = SharedResources.UsersFeed.GetNextItem(context.ScenarioInfo);
				
                int thinkTimeBetweenSteps = SharedResources.thinkTimeBetweenSteps;
				string securityToken = null;

                var request01 = await Step.Run("01_Authenticate", context, async () =>
                {
                   iterationStart = DateTime.UtcNow;
                    var response = await Task.Run(() => SharedResources.RequestClient.Authenticate(user));
                    StringAssert.Contains(response.AuthenticateResult.Result.ToString(), "Success");

                    securityToken = response.AuthenticateResult.Credentials.SecurityToken; // assign value from a response.

                    await Task.Delay(thinkTimeBetweenSteps);
                    return Response.Ok();
                });

                 **if (_random.NextDouble() <= 0.02) // run with only 02% probability
                 {**
				var request02 = await Step.Run("02_GetCustomers", context, async () =>
				{
					var response = await Task.Run(() => SharedResources.RequestClient.GetAccounts(accountId));
					StringAssert.Contains(response.GetAccountsResult.Result.ToString(), "Success");

					await Task.Delay(thinkTimeBetweenSteps);
					return Response.Ok();
				});       				
		}       

                var request03 = await Step.Run("03_Logout", context, async () =>
                {
                    var response = await Task.Run(() => SharedResources.RequestClient.Logout(securityToken));
                    StringAssert.Contains(response.LogoutResult.Result.ToString(), "Success");

                    await Task.Delay(thinkTimeBetweenSteps);
                    return Response.Ok();
                });

        // see note above about this code
       **var elapsed = (DateTime.UtcNow - iterationStart!.Value).TotalMilliseconds;
          var remaining = targetIntervalMs - elapsed;
          if (remaining > 0)
          {
              await Task.Delay((int)remaining);
          }**

          return NBomber.CSharp.Response.Ok();
      })
     .WithWarmUpDuration(TimeSpan.FromSeconds(5)) // gets rid of response time bump on the HTML chart.
          .WithLoadSimulations(
              Simulation.RampingConstant(copies: initCopies, during: TimeSpan.FromSeconds(3)),
              Simulation.RampingConstant(copies: maxCopies, during: TimeSpan.FromMinutes(durationInMinutes)))
          .WithInit(context =>
          {
              SharedResources.InitializeDataFeeds();

              return Task.CompletedTask;
          });

      return scenario;
  }
    }

[AntyaDev]

Hi @CMorrisonJHA
You are 100% right! It would be nice to add them.
Thank you a lot!

[AntyaDev]

@CMorrisonJHA
var response = await Task.Run(() => SharedResources.RequestClient.Authenticate(user));

it seems to me you can just block here
var response = SharedResources.RequestClient.Authenticate(user);

[CMorrisonJHA]

You are right to be concerned about potential blocking in the RequestClient.
For most tests designed for pipeline use, we could place one RequestClient at the top of each scenario class. This would do for most situations.
However, for long-running, complex load tests (including capacity tests which have a greater chance of breaking both the system under test as well as the load test), we need a robust, error-handling, self-regenerating, thread-safe client. (sometimes a pool of clients is the best approach).

In my Visual Studio solution I have coded such a RequestClient and placed it in yet another class (following the separation of concerns principle). I did not post this class above. But it would look something like what is below.

The example below follows Microsoft's recommendations to use a static/singleton HttpClient with a correctly configured SocketsHttpHandler with Polly resilience (timeout + circuit‑breaker + bulkhead), and automatic re‑creation of the client when a fault threshold is hit.

Micorosoft's guidance is a starting place for a non-blocking client.

Let me know if you feel I am on the wrong track with this. (Is there something else in NBomber or in my file structure which would block? The data sources?)

Static HttpClient with resilience Plus Other Features

using System;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using Polly;
using Polly.CircuitBreaker;
using Polly.Timeout;
using Polly.Bulkhead;
using Polly.Wrap;

public static class LoadTestHttp
{
    // Single, shared HttpClient. Thread-safe and intended to be reused.
    private static HttpClient _client = CreateHttpClient();
    private static readonly object _swapLock = new();

    private static HttpClient CreateHttpClient()
    {
        var handler = new SocketsHttpHandler
        {
            // Tune for throughput; remove if you prefer the platform default
            MaxConnectionsPerServer = 256,
            AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
        };

        var client = new HttpClient(handler, disposeHandler: true)
        {
            // Let Polly control timeouts per request
            Timeout = Timeout.InfiniteTimeSpan,
            DefaultRequestVersion = HttpVersion.Version20,
            DefaultVersionPolicy = HttpVersionPolicy.RequestVersionOrHigher
        };

        client.DefaultRequestHeaders.UserAgent.ParseAdd("LoadTestClient/1.0");
        client.DefaultRequestHeaders.Accept.Add(
            new MediaTypeWithQualityHeaderValue("application/json"));

        return client;
    }

    // --- Resilience without retries ---
    // Fail fast per request so threads aren't blocked by slow calls.
    private static readonly IAsyncPolicy<HttpResponseMessage> TimeoutPolicy =
        Policy.TimeoutAsync<HttpResponseMessage>(TimeSpan.FromSeconds(15), TimeoutStrategy.Optimistic);

    // Optional: cap concurrency per client to avoid thread contention.
    private static readonly IAsyncPolicy<HttpResponseMessage> BulkheadPolicy =
        Policy.BulkheadAsync<HttpResponseMessage>(maxParallelization: 500, maxQueuingActions: 0);

    // Trip on repeated SUT/network faults; when tripped, re-create the client.
    private static readonly AsyncCircuitBreakerPolicy<HttpResponseMessage> BreakerPolicy =
        Policy<HttpResponseMessage>
            .Handle<HttpRequestException>()
            .OrResult(r =>
                r.StatusCode == HttpStatusCode.RequestTimeout ||
                (int)r.StatusCode >= 500)
            .CircuitBreakerAsync(
                handledEventsAllowedBeforeBreaking: 50,      // tune to your ramp pattern
                durationOfBreak: TimeSpan.FromSeconds(30),   // cool-down
                onBreak: (outcome, delay) => RegenerateClient(),
                onReset: () => { /* optional trace */ },
                onHalfOpen: () => { /* optional trace */ });

    private static readonly AsyncPolicyWrap<HttpResponseMessage> Pipeline =
        Policy.WrapAsync(BulkheadPolicy, BreakerPolicy, TimeoutPolicy);

    private static void RegenerateClient()
    {
        lock (_swapLock)
        {
            var old = _client;
            _client = CreateHttpClient();
            old.Dispose();    // drop old pool; new pool starts clean
        }
    }

    public static async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request,
        CancellationToken ct = default)
    {
        return await Pipeline.ExecuteAsync(token =>
            _client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, token), ct);
    }

    public static async Task<string> GetStringAsync(string url, CancellationToken ct = default)
    {
        using var req = new HttpRequestMessage(HttpMethod.Get, url);
        using var resp = await SendAsync(req, ct);
        resp.EnsureSuccessStatusCode(); // surface failures to the harness
        return await resp.Content.ReadAsStringAsync(ct);
    }
}

References

• https://makolyte.com/csharp-how-to-make-concurrent-requests-with-httpclient/
• https://learn.microsoft.com/en-us/dotnet/architecture/microservices/implement-resilient-applications/implement-http-call-retries-exponential-backoff-polly
• https://stackoverflow.com/questions/79593567/why-use-sethandlerlifetime-at-all-when-we-already-have-pooledconnectionlif
• https://www.aspnetmonsters.com/2016/08/2016-08-27-httpclientwrong/
• https://stackoverflow.com/questions/67127406/why-using-httpclient-in-a-using-block-is-wrong-in-webapi-context
• https://amarozka.dev/dont-new-up-httpclient-use-ihttpclientfactory/

The above is an illustration of a fault-tolerant HTTPClient, that I WOULD build if I was using REST or HTTP calls. I should note that I have not actually implemented the above code (but I have implemented clients like it.)

Note that for actual load testing use, we usually don't want to retry.: if a request fails because the system under test has a problem, we want to mark that request as an failure of the system under test. But we DO want to "retry" if the client lifetime expired (e.g., in endurance tests), and we also want to get a new client AFTER the client has faulted (so that we can continue with the test).

Automatic retries in load testing can mask true SUT (system under test) failures and inflate perceived throughput/latency. We do want the client to recover and keep sending load after a failure—e.g., by re‑creating the HttpClient when there’s evidence of systemic faults (timeouts, repeated 5xx, connection errors).

For better or worse, the current system I'm testing uses WCF (Microsoft SOAP, XML requests). For this project, I have implemented a very similar fault tolerant client (with a client pool) except it is for WCF and uses WCF channel factories. I would be glad to post that here as well, but it's 350 lines long . .. .

My WCF client uses a pool of WCF channels. Each channel is returned to the pool after its lifetime. If a channel gets faulted, the request automatically gets another channel from the pool.

If you still feel that there might be blocking due to NBomber internal architecture, or something else I might have wrong, please let me know. I actually have not yet tested my WCF client at very high volume. My high volume test will start at 800 threads, and ramp up to about 2500 threads. It is a capacity test that is designed to knock over my Production system, so in my client I anticipate that there's going to be http 500's, timeouts, channel faults, etc.

[CMorrisonJHA]

Note that it might be cleaner and shorter to write the HTTP client using Dependency Injection:

using System.Net;
using System.Net.Http;
using Microsoft.Extensions.DependencyInjection;
using Polly;
using Polly.Extensions.Http;
using Polly.Timeout;

public static class TestBootstrap
{
    public static IServiceProvider BuildServices()
    {
        var services = new ServiceCollection();

        // Register a typed client—no DNS refresh, no retries
        services.AddHttpClient<LoadTestApiClient>(client =>
        {
            client.DefaultRequestVersion = HttpVersion.Version20;
            client.DefaultVersionPolicy = HttpVersionPolicy.RequestVersionOrHigher;
            client.Timeout = Timeout.InfiniteTimeSpan; // use Polly's per-request timeout
            client.DefaultRequestHeaders.UserAgent.ParseAdd("LoadTestClient/1.0");
        })
        .ConfigurePrimaryHttpMessageHandler(() => new SocketsHttpHandler
        {
            MaxConnectionsPerServer = 256,
            AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate
        })
        // Resilience: timeout + circuit breaker; no retry for load tests
        .AddPolicyHandler(Policy.TimeoutAsync<HttpResponseMessage>(
            TimeSpan.FromSeconds(15), TimeoutStrategy.Optimistic))
        .AddPolicyHandler(HttpPolicyExtensions
            .HandleTransientHttpError()
            .OrResult(r => r.StatusCode == HttpStatusCode.RequestTimeout || (int)r.StatusCode >= 500)
            .CircuitBreakerAsync(handledEventsAllowedBeforeBreaking: 50, durationOfBreak: TimeSpan.FromSeconds(30)));

        return services.BuildServiceProvider(validateScopes: true);
    }
}

Client

// Clients.cs
using Microsoft.Extensions.DependencyInjection;

public static class Clients
{
    private static readonly IServiceProvider _provider = TestBootstrap.BuildServices();

    public static LoadTestApiClient CreateLoadClient()
        => _provider.GetRequiredService<LoadTestApiClient>();
}

In test Method

var client = Clients.CreateLoadClient();
var payload = await client.GetStringAsync("https://your-sut.example/api/ping", 

Polly is open-source, NuGet-based, and endorsed by Microsoft because it makes resilience easy, composable, and production-ready for .NET apps. It's shorter because IHttpClientFactory and the DI container hide a lot of the boilerplate (client creation, handler pooling/rotation, disposal, and policy wiring). With DI, you declaratively attach policies to a named/typed client, while the factory manages lifecycle and pooling for you

• https://devblogs.microsoft.com/dotnet/building-resilient-cloud-services-with-dotnet-8/
• https://learn.microsoft.com/en-us/dotnet/architecture/microservices/implement-resilient-applications/implement-http-call-retries-exponential-backoff-polly
• https://github.com/App-vNext/Polly/wiki/Polly-and-HttpClientFactory
• https://devblogs.microsoft.com/dotnet/tag/polly/
• https://devblogs.microsoft.com/ise/build-test-resilience-dotnet-functions/

[CMorrisonJHA]

Here is a WCF client using Dependency Injection and Polly. I might change my current WCF client implementation to this.
My current implementation does not use Polly or DI and that's why it's 350 lines long . . . .

// WcfClient.cs
using System;
using System.ServiceModel;
using System.Threading;
using System.Threading.Tasks;
using Polly;

public sealed class WcfClient<TService>
    where TService : class
{
    private readonly ChannelFactory<TService> _factory;
    private readonly IAsyncPolicy _pipeline;

    public WcfClient(ChannelFactory<TService> factory, IAsyncPolicy pipeline)
    {
        _factory  = factory ?? throw new ArgumentNullException(nameof(factory));
        _pipeline = pipeline ?? throw new ArgumentNullException(nameof(pipeline));
    }

    /// <summary>
    /// Invokes an async service operation under the configured Polly pipeline.
    /// Automatically applies the Close-or-Abort pattern recommended by Microsoft.
    /// </summary>
    public async Task<TResult> InvokeAsync<TResult>(
        Func<TService, Task<TResult>> call,
        CancellationToken ct = default)
    {
        var channel   = _factory.CreateChannel();
        var commObj   = (IClientChannel)channel;

        try
        {
            // Open is optional; WCF will open lazily on first call. Add if your binding needs it.
            // commObj.Open();

            var result = await _pipeline.ExecuteAsync(_ =>
                call(channel), ct);

            // Safe close after success
            SafeClose(commObj);
            return result;
        }
        catch (CommunicationException)
        {
            SafeAbort(commObj);     // recommended when channel is faulted
            throw;
        }
        catch (TimeoutException)
        {
            SafeAbort(commObj);
            throw;
        }
        catch
        {
            SafeAbort(commObj);
            throw;
        }
    }

    private static void SafeClose(IClientChannel channel)
    {
        try
        {
            if (channel.State == CommunicationState.Faulted)
                channel.Abort();
            else
                channel.Close();
        }
        catch
        {
            channel.Abort();
        }
    }

    private static void SafeAbort(IClientChannel channel)
    {
        try { channel.Abort(); } catch { /* swallow */ }
    }
}