TResult Fallback is incorrectly null [when non-generic Fallback policy is used with generic Execute<TResult> overloads]

[jonnovaretti]

I'm creating a PolicyWrap with CircuitBreak and Fallback. When all occurs right, PolicyResult returns with my result, but when ocurrs a exception and the Fallback executes the PolicyResult bring result null or default value. I created a little test just with Fallback and the result is the same.

[TestMethod]
        public void Verificar_Funcionamento_Fallback()
        {
            FallbackPolicy policy;

            policy = Policy.Handle<DivideByZeroException>().Fallback(() => DivideWithoutZero(3, 0));

            var result = policy.ExecuteAndCapture(() => Divide(3, 0));
        }

        private int Divide(int x, int y)
        {
            Thread.Sleep(2000);
            var z = x / y;

            return z;
        }

        private int DivideWithoutZero(int v1, int v2)
        {
            int result = 99;

            if (v2 > 0)
                result = v1 / v2;

            return result;
        }

What did I do wrong?

[reisenberger]

Hi. Declaring the policy explicitly as FallbackPolicy policy has declared a non-generic policy. The compiler thus picks up this configuration overload: .Fallback(Action fallbackAction)

That this is not jumping out as a problem is in part caused by the fact that the compiler will silently accept assigning a Func<int> to an Action. It's not an error - it's just as you could execute DivideWithoutZero(3, 0); as a statement, without doing anything with its return value - but there isn't any warning to you from the compiler that this is happening.

Instead, you need to declare that the policy is explicitly for delegates returning int:

FallbackPolicy<int> policy = Policy<int>.Handle<DivideByZeroException>().Fallback(() => DivideWithoutZero(3, 0));

[reisenberger]

@jonnovaretti Thanks for raising this. Did the suggestion fix for you?

I think we should fix this in Polly so that it's not possible to fall into the situation you encountered. The combination is:

(1) A plain (non-generic) FallbackPolicy configures an Action fallbackAction to run in case of fallback
(2) All Polly non-Generic policies let you use a generic execute method .Execute<TResult>(...). But a generic-TResult execution for a plain FallbackPolicy doesn't make sense, because the Action fallbackAction configured can only ever return void, so can never provide a substitute TResult value.

As a result, I think we should treat FallbackPolicy (non-generic) .Execute<TResult>(...) as an InvalidOperationException.

[reisenberger]

Marking 'up-for-grabs'. Needed:

• override the generic method overloads .Execute<TResult>(...), on non-generic FallbackPolicy, so that they throw InvalidOperationException (for the reasons described in prev. comment).
• unit tests

[reisenberger]

Fixed in Polly v5.6.0 (will be released via nuget in next day or so). Now throws an exception as warning, when non-generic FallbackPolicy is used with generic methods .Execute<TResult>(...), with explanatory message:

You have executed the generic .Execute<TResult> method on a non-generic FallbackPolicy.  
A non-generic FallbackPolicy only defines a fallback action which returns void; it can never return a substitute TResult value.  
To use FallbackPolicy to provide fallback TResult values you must define a generic fallback policy FallbackPolicy<TResult>.  
For example, define the policy as Policy<TResult>.Handle<Whatever>.Fallback<TResult>(/* some TResult value or Func<..., TResult> */);