[Question]: Replacing ResiliencePipelineProvider with keyed services

[pekspro]

What are you wanting to achieve?

In .NET 8, support for keyed services has been added. I think this can replace ResiliencePipelineProvider in many scenarios.

What code or approach do you have so far?

I did this little test:

public class MyApi2
{
    private readonly ResiliencePipeline _pipeline;

    public MyApi2([FromKeyedServices("my-pipeline2")] ResiliencePipeline pipeline)
    {
        _pipeline = pipeline;
    }

    public async Task ExecuteAsync(CancellationToken cancellationToken)
    {
        await _pipeline.ExecuteAsync(
            static async token =>
            {
                // Add your code here
            },
            cancellationToken);
    }
}

public static class MyApi2Extensions
{
    public static IServiceCollection AddMyApi2(this IServiceCollection services)
    {
        ResiliencePipeline pipeline = new ResiliencePipelineBuilder()
            .AddRetry(new RetryStrategyOptions
            {
                MaxRetryAttempts = 4
            })
            .Build();

        services.AddKeyedSingleton<ResiliencePipeline>("my-pipeline2", pipeline);

        services.AddSingleton<MyApi2>();

        return services;
    }
}

This seems to work. The main benefit of this is there is no longer a need to mock ResiliencePipelineProvider in unit tests.

I have been a bit suspicious of keyed services, but for Polly it seems to be a perfect match 😊. But I’m a bit surprised there is no documentation about this, not any discussions. Are there any drawbacks with this approach? Feels like I’m missing something.

Additional context

No response

[martincostello]

You shouldn't need to mock a pipeline provider, as you could just create an empty one with nothing configured and build it, which will give you a no-op strategy that does nothing other than invoke the delegate you wrap with it.

Keyed services isn't mentioned in our documentation because we just didn't look into it as we were busy getting Polly v8 ready for .NET 8 itself to make use of.

If you'd like to contribute an example to our documentation suggesting how one could use keyed services to configure Polly resilience strategies, that would be interesting.

[pekspro]

Thanks for a very quick reply. Didn’t expect that at this time of year 😊.

How do you create an empty pipeline provider for testing? Reading here it looks like you are suggested to make a mock.

Here is a very rough draft how documentation could look like when using keyed services. It’s based on Dependency injection on getting started page. Again, I do not understand what I’m doing, just playing around 😊. I assume there are some feature you would lose with this approach.

Dependency injection

If you prefer to define resilience pipelines using IServiceCollection, you'll need to install the Polly.Extensions package:

dotnet add package Polly.Extensions

then you can define your resilience pipeline as shown:

var services = new ServiceCollection();

ResiliencePipeline pipelineToAdd = new ResiliencePipelineBuilder()
    .AddRetry(new RetryStrategyOptions())
    .AddTimeout(TimeSpan.FromSeconds(10))
    .Build();

// Define a resilience pipeline with the name "my-pipeline"
services.AddKeyedSingleton<ResiliencePipeline>("my-pipeline", pipelineToAdd);

// Build the service provider
var serviceProvider = services.BuildServiceProvider();

// Retrieve your resilience pipeline using the key
ResiliencePipeline pipeline = serviceProvider.GetRequiredKeyedService<ResiliencePipeline>("my-pipeline");

// Execute the pipeline
await pipelineToAdd.ExecuteAsync(static async token =>
{
    // Your custom logic goes here
});

[martincostello]

Ah, sorry, I was thinking of a pipeline itself, which would be done thusly:

ResiliencePipeline pipeline = new ResiliencePipelineBuilder().Build();

If your constructor took a named pipeline, then you could just directly inject an empty pipeline to it without any reference to a pipeline provider at all.

[pekspro]

Thanks @martincostello. But isn't:

ResiliencePipeline pipeline = new ResiliencePipelineBuilder().Build();

the same as:

ResiliencePipeline pipeline = ResiliencePipeline.Empty;

?

Is there any ResiliencePipelineProvider that can be used for testing that always returns an empty ResiliencePipeline? Would be nice to avoid creating a mock and configure it. Thinking something like this:

public class EmptyResiliencePipelineProvider : ResiliencePipelineProvider<string>
{
    public override bool TryGetPipeline(string key, [NotNullWhen(true)] out ResiliencePipeline? pipeline)
    {
        pipeline = ResiliencePipeline.Empty;

        return true;
    }

    public override bool TryGetPipeline<TResult>(string key, [NotNullWhen(true)] out ResiliencePipeline<TResult>? pipeline)
    {
        pipeline = ResiliencePipeline<TResult>.Empty;

        return true;
    }
}

[martincostello]

Yes they are the same, I just forgot the property existed.

Personally I'm not keen on adding this mock/substitute in-box as it isn't so simple as an empty pipeline because it has parameters to provide different names, so there's many ways people might want it to behave and then it's a slippery slope of "what about one that behaves this way?".

This is trivial to implement as a mock in your tests and you can factor it for re-use in your tests to reduce duplication.

[martintmk]

@pekspro What we can do in Polly is something like this automatically:

services.AddKeyedSingleton(
    key,
    (serviceProvider, key) =>
    {
        var pipelineProvider = serviceProvider.GetRequiredService<ResiliencePipelineProvider<TKey>>();

        return pipelineProvider.GetPipeline((TKey)key!);
    });

Basically, whenever the AddResiliencePipeline is called, we can also register a keyed singleton ResiliencePipeline.

Then, the following should work:

services.AddResiliencePipeline("my-pipeline2", builder => ... );

public class MyApi2
{
    private readonly ResiliencePipeline _pipeline;

    public MyApi2([FromKeyedServices("my-pipeline2")] ResiliencePipeline pipeline)
    {
        _pipeline = pipeline;
    }
}

There are couple of limitations with keyed services:

• Deferred pipelines won't be registered as keyed singletons because we don't know what pipelines are being added at registration time.
• Complex pipeline keys won't be supported. This is because the complex key is provided at access time and we can only register single keyed singleton for such key. (known when pipeline is defined)

[pekspro]

Thanks, @martintmk, that sounds like a great idea. At least to me, but again I rarely understand what I'm doing 😊. Personally, I don't mind the limitations at all.

One nice thing with keyed services, is that when Build is called in the ServiceCollection, it verifies that all services can be created. So, if you ask for a (keyed) services that isnt't registrered, you will get an exception.

[martintmk]

@pekspro

I have created a PR that adds support for keyed services (#1881)