Is it possible to handle different exceptions differently with the same policy?

I just started digging into Polly and I really like it. One thing I can’t quite seem to figure out how to do is to have a Policy that reacts differently to different exception types.

I’d like to do something like this:

// don't need to reconnect on a CommandException
myPolicy = Policy
.Handle<CommandException>()               
.Retry(10);

// but need to reconnect before a retry when an IOException occurs
myPolicy.Handle<IOException>()
.Retry(10, (exception, retryCount, context) => 
{    
    Reconnect();
});

myPolicy.Execute(Command);

Is this possible?

[reisenberger]

Hi @BertLamb Using .Or<TException> lets you handle more than one type of exception in the same policy. And, the exception just thrown is passed the to onRetry delegate before the next try commences, so you can vary onRetry actions depending on the exception causing the retry. So:

// don't need to reconnect on a CommandException
// but need to reconnect before a retry when an IOException occurs
myPolicy = Policy
    .Handle<CommandException>()
    .Or<IOException>()               
    .Retry(10, (exception, retryCount, context) => 
    {    
        if (exception is IOException) { Reconnect(); }
    });

myPolicy.Execute(Command);

Does this cover it? Let us know if you have any other questions!

[reisenberger]

Hi @BertLamb . To do that with Polly, you can define separate policies and nest them, as described in the wiki here or as shown below:

var retryPolicy = Policy
    .Handle<CommandException>()
    .Retry(10, (exception, retryCount, context) => Reconnect());
var circuitBreaker = Policy
    .Handle<IOException>
    .CircuitBreaker(2, TimeSpan.FromMinutes(1));

retryPolicy.Execute(() => circuitBreaker.Execute(command));

There isn’t currently a way to define a Policy that handles a variety of different exceptions in a variety of different ways, all in one single fluent statement. However, the Polly Roadmap envisages the Polly Pipeline, which would allow any number of functionally-composed policies to be reduced to one Policy, thus:

var combinedPolicy = Policy.Pipeline(retryPolicy, circuitBreaker);
combinedPolicy.Execute(command);

or (an alternative syntax under consideration):

var combinedPolicy = retryPolicy.Wrap(circuitBreaker);
combinedPolicy.Execute(command);

I guess once the functionality for collapsing functionally-composed (wrapped) policies into one (as in the Polly Pipeline) was in place, it might be possible to create an on-going fluent syntax as follows - is this the kind of thing you had in mind?

var myPolicy = Policy
    .Handle<CommandException>()
    .Retry(10, (exception, retryCount, context) => Reconnect());
    .Handle<IOException>
    .CircuitBreaker(2, TimeSpan.FromMinutes(1));

myPolicy.Execute(command);