[Docs] Add clarification about property precedence

.github/wordlist.txt

@@ -13,6 +13,7 @@ deserialization
 dotnet
 dotnetrocks
 durations
+enum
 eshoponcontainers
 extensibility
 flurl

docs/chaos/index.md

@@ -66,7 +66,7 @@ Chaos strategies (formerly known as Monkey strategies) are in essence a [Resilie
 | [Fault](fault.md)       | No       | Injects exceptions in your system.                                   |
 | [Outcome](outcome.md)   | Yes      | Injects fake outcomes (results or exceptions) in your system.        |
 | [Latency](latency.md)   | No       | Injects latency into executions before the calls are made.           |
-| [Behavior](behavior.md) | No       | Allows you to inject *any* extra behaviour, before a call is placed. |
+| [Behavior](behavior.md) | No       | Allows you to inject *any* extra behavior, before a call is placed.  |
 
 ## Common options across strategies
 
@@ -85,6 +85,8 @@ All the strategies' options implement the [`ChaosStrategyOptions`](xref:Polly.Si
 | `EnabledGenerator`       | `null`        | The generator that indicates whether the chaos strategy is enabled for a given execution.                                                                                                                                        |
 
 > [!NOTE]
+> If both `InjectionRate` and `InjectionRateGenerator` are specified then `InjectionRate` will be ignored.
+>
 > If both `Enabled` and `EnabledGenerator` are specified then `Enabled` will be ignored.
 
 [simmy]: https://github.com/Polly-Contrib/Simmy

docs/strategies/circuit-breaker.md

@@ -105,6 +105,9 @@ new ResiliencePipelineBuilder<HttpResponseMessage>().AddCircuitBreaker(optionsSt
 | `ManualControl`          | `null`                                                                     | Allows for manual control to isolate or close the circuit.                                 |
 | `StateProvider`          | `null`                                                                     | Enables the retrieval of the current state of the circuit.                                 |
 
+> [!NOTE]
+> If both `BreakDuration` and `BreakDurationGenerator` are specified then `BreakDuration` will be ignored.
+
 ## Diagrams
 
 ### State diagram

docs/strategies/hedging.md

@@ -60,19 +60,22 @@ new ResiliencePipelineBuilder<HttpResponseMessage>().AddHedging(optionsDefaults)
 ## Defaults
 
 | Property            | Default Value                                                              | Description                                                                              |
-| ------------------- | -------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------- |
+|---------------------|----------------------------------------------------------------------------|------------------------------------------------------------------------------------------|
 | `ShouldHandle`      | Predicate that handles all exceptions except `OperationCanceledException`. | Predicate that determines what results and exceptions are handled by the retry strategy. |
 | `MaxHedgedAttempts` | 1                                                                          | The maximum number of hedged actions to use, in addition to the original action.         |
 | `Delay`             | 2 seconds                                                                  | The maximum waiting time before spawning a new hedged action.                            |
 | `ActionGenerator`   | Returns the original callback that was passed to the hedging strategy.     | Generator that creates hedged actions.                                                   |
-| `DelayGenerator`    | `null`                                                                     | Used for generating custom delays for hedging. If `null` then `Delay` is used.           |
+| `DelayGenerator`    | `null`                                                                     | Used for generating custom delays for hedging.                                           |
 | `OnHedging`         | `null`                                                                     | Event that is raised when a hedging is performed.                                        |
 
 You can use the following special values for `Delay` or in `DelayGenerator`:
 
 - `0 seconds` - the hedging strategy immediately creates a total of `MaxHedgedAttempts` and completes when the fastest acceptable result is available.
 - `-1 millisecond` - this value indicates that the strategy does not create a new hedged task before the previous one completes. This enables scenarios where having multiple concurrent hedged tasks can cause side effects.
 
+> [!NOTE]
+> If both `Delay` and `DelayGenerator` are specified then `Delay` will be ignored.
+
 ## Concurrency modes
 
 In the sections below, explore the different concurrency modes available in the hedging strategy. The behavior is primarily controlled by the `Delay` property value.

docs/strategies/retry.md

@@ -108,6 +108,55 @@ new ResiliencePipelineBuilder<HttpResponseMessage>().AddRetry(optionsExtractDela
 | `OnRetry`          | `null`                                                                     | Action executed when retry occurs.                                                       |
 | `MaxDelay`         | `null`                                                                     | Caps the calculated retry delay to a specified maximum duration.                         |
 
+## Calculation of the next delay
+
+If the `ShouldHandle` predicate returns `true` and the next attempt number is not greater than `MaxRetryAttempts` then the retry strategy calculates the next delay.
+
+There are many properties that are somehow contribute to this calculation:
+
+- `Delay`
+- `DelayGenerator`
+- `MaxDelay`
+- `UseJitter`
+- `BackoffType`
+
+> [!IMPORTANT]
+> The below described algorithm is an implementation detail. It might change in the future without further notice.
+>
+> Also please bear in mind that some details are not mentioned here to keep the algorithm description short and terse.
+
+The `BackoffType` property's data type is a [`DelayBackOffType`](xref:Polly.DelayBackOffType) enum. This controls primarily how the calculation is done.
+
+### Constant
+
+One might think that here we only put into the account the `Delay` property. In reality all above listed properties are used.
+
+Step 1: Calculating the base delay:
+
+- If `UseJitter` is set to `false` and `Delay` is specified then `Delay` will be used.
+- If `UseJitter` is set to `true` and `Delay` is specified then a random value is added to the `Delay`.
+  - The random value is between [-25% of `Delay`, +25% of `Delay`].
+
+Step 2: Capping the delay if needed:
+
+- If the previously calculated delay is greater than `MaxDelay` then `MaxDelay` will be used.
+
+Step 3: Using the generator if supplied
+
+- If the returned `TimeSpan` of the `DelayGenerator` method call is positive then it will be used.
+- If the returned `TimeSpan` of the `DelayGenerator` method call is negative then it will use the step 2's result.
+
+> [!NOTE]
+> The `DelayGenerator`'s returned value is not capped with the `MaxDelay`.
+
+### Linear
+
+### Exponential
+
+> [!TIP]
+> For more details please check out the [`RetryHelper`](https://github.com/App-vNext/Polly/blob/main/src/Polly.Core/Retry/RetryHelper.cs)
+> and the [`RetryResilienceStrategy`](https://github.com/App-vNext/Polly/blob/main/src/Polly.Core/Retry/RetryResilienceStrategy.cs) classes.
+
 ## Diagrams
 
 Let's suppose we have a retry strategy with `MaxRetryAttempts`: `2`.

docs/strategies/timeout.md

@@ -125,6 +125,9 @@ The `OnTimeout` delegate can be useful when you define a resilience pipeline whi
 | `TimeoutGenerator` | `null`        | Generates the timeout for a given execution. |
 | `OnTimeout`        | `null`        | Event that is raised when timeout occurs.    |
 
+> [!NOTE]
+> If both `Timeout` and `TimeoutGenerator` are specified then `Timeout` will be ignored.
+
 ## Diagrams
 
 ### Happy path sequence diagram