Drop object-based outcome conversions

martintmk · martintmk · commit 37318c41b501 · 2023-08-29T11:48:21.000+02:00
diff --git a/src/Polly.Core/CircuitBreaker/CircuitBreakerResiliencePipelineBuilderExtensions.cs b/src/Polly.Core/CircuitBreaker/CircuitBreakerResiliencePipelineBuilderExtensions.cs
@@ -77,6 +77,7 @@ internal static CircuitBreakerResilienceStrategy<TResult> CreateStrategy<TResult
             options.MinimumThroughput,
             HealthMetrics.Create(options.SamplingDuration, context.TimeProvider));
 
+#pragma warning disable CA2000 // Dispose objects before losing scope
         var controller = new CircuitStateController<TResult>(
             options.BreakDuration,
             options.OnOpened,
@@ -85,6 +86,7 @@ internal static CircuitBreakerResilienceStrategy<TResult> CreateStrategy<TResult
             behavior,
             context.TimeProvider,
             context.Telemetry);
+#pragma warning restore CA2000 // Dispose objects before losing scope
 
         return new CircuitBreakerResilienceStrategy<TResult>(
             options.ShouldHandle!,
diff --git a/src/Polly.Core/CircuitBreaker/CircuitBreakerResilienceStrategy.cs b/src/Polly.Core/CircuitBreaker/CircuitBreakerResilienceStrategy.cs
@@ -15,7 +15,7 @@ public CircuitBreakerResilienceStrategy(
         _handler = handler;
         _controller = controller;
 
-        stateProvider?.Initialize(() => _controller.CircuitState, () => _controller.LastHandledOutcome);
+        stateProvider?.Initialize(() => _controller.CircuitState);
         _manualControlRegistration = manualControl?.Initialize(
             async c => await _controller.IsolateCircuitAsync(c).ConfigureAwait(c.ContinueOnCapturedContext),
             async c => await _controller.CloseCircuitAsync(c).ConfigureAwait(c.ContinueOnCapturedContext));
diff --git a/src/Polly.Core/CircuitBreaker/CircuitBreakerStateProvider.cs b/src/Polly.Core/CircuitBreaker/CircuitBreakerStateProvider.cs
@@ -6,17 +6,15 @@ namespace Polly.CircuitBreaker;
 public sealed class CircuitBreakerStateProvider
 {
     private Func<CircuitState>? _circuitStateProvider;
-    private Func<Outcome<object>?>? _lastHandledOutcomeProvider;
 
-    internal void Initialize(Func<CircuitState> circuitStateProvider, Func<Outcome<object>?> lastHandledOutcomeProvider)
+    internal void Initialize(Func<CircuitState> circuitStateProvider)
     {
         if (_circuitStateProvider != null)
         {
             throw new InvalidOperationException($"This instance of '{nameof(CircuitBreakerStateProvider)}' is already initialized and cannot be used in a different circuit-breaker strategy.");
         }
 
         _circuitStateProvider = circuitStateProvider;
-        _lastHandledOutcomeProvider = lastHandledOutcomeProvider;
     }
 
     /// <summary>
@@ -32,11 +30,4 @@ internal void Initialize(Func<CircuitState> circuitStateProvider, Func<Outcome<o
     /// Gets the state of the underlying circuit.
     /// </summary>
     public CircuitState CircuitState => _circuitStateProvider?.Invoke() ?? CircuitState.Closed;
-
-    /// <summary>
-    /// Gets the last outcome handled by the circuit-breaker.
-    /// <remarks>
-    /// This will be null if no exceptions or results have been handled by the circuit-breaker since the circuit last closed.</remarks>
-    /// </summary>
-    internal Outcome<object>? LastHandledOutcome => _lastHandledOutcomeProvider?.Invoke();
 }
diff --git a/src/Polly.Core/CircuitBreaker/Controller/CircuitStateController.cs b/src/Polly.Core/CircuitBreaker/Controller/CircuitStateController.cs
@@ -18,7 +18,7 @@ internal sealed class CircuitStateController<T> : IDisposable
     private readonly TimeSpan _breakDuration;
     private DateTimeOffset _blockedUntil;
     private CircuitState _circuitState = CircuitState.Closed;
-    private Outcome<object>? _lastOutcome;
+    private Outcome<T>? _lastOutcome;
     private BrokenCircuitException _breakingException = new();
     private bool _disposed;
 
@@ -66,7 +66,7 @@ public Exception? LastException
         }
     }
 
-    public Outcome<object>? LastHandledOutcome
+    public Outcome<T>? LastHandledOutcome
     {
         get
         {
@@ -290,17 +290,17 @@ private bool PermitHalfOpenCircuitTest_NeedsLock()
         return false;
     }
 
-    private void SetLastHandledOutcome_NeedsLock<TResult>(Outcome<TResult> outcome)
+    private void SetLastHandledOutcome_NeedsLock(Outcome<T> outcome)
     {
-        _lastOutcome = Outcome.ToObjectOutcome(outcome);
+        _lastOutcome = outcome;
 
         if (outcome.Exception is Exception exception)
         {
             _breakingException = new BrokenCircuitException(BrokenCircuitException.DefaultMessage, exception);
         }
         else if (outcome.TryGetResult(out var result))
         {
-            _breakingException = new BrokenCircuitException<TResult>(BrokenCircuitException.DefaultMessage, result!);
+            _breakingException = new BrokenCircuitException<T>(BrokenCircuitException.DefaultMessage, result!);
         }
     }
 
diff --git a/src/Polly.Core/Hedging/Controller/HedgingExecutionContext.cs b/src/Polly.Core/Hedging/Controller/HedgingExecutionContext.cs
@@ -156,9 +156,7 @@ private ExecutionInfo<T> CreateExecutionInfoWhenNoExecution()
             var finishedExecution = _tasks.First(static t => t.ExecutionTaskSafe!.IsCompleted);
             finishedExecution.AcceptOutcome();
 
-            var outcome = Outcome.FromObjectOutcome<T>(finishedExecution.Outcome);
-
-            return new ExecutionInfo<T>(null, false, outcome);
+            return new ExecutionInfo<T>(null, false, finishedExecution.Outcome);
         }
 
         return new ExecutionInfo<T>(null, false, null);
diff --git a/src/Polly.Core/Hedging/Controller/TaskExecution.cs b/src/Polly.Core/Hedging/Controller/TaskExecution.cs
@@ -49,7 +49,7 @@ public TaskExecution(HedgingHandler<T> handler, CancellationTokenSourcePool canc
     /// </remarks>
     public Task? ExecutionTaskSafe { get; private set; }
 
-    public Outcome<object> Outcome { get; private set; }
+    public Outcome<T> Outcome { get; private set; }
 
     public bool IsHandled { get; private set; }
 
@@ -225,7 +225,7 @@ private async Task ExecutePrimaryActionAsync<TState>(Func<ResilienceContext, TSt
     private async Task UpdateOutcomeAsync(Outcome<T> outcome)
     {
         var args = new HedgingPredicateArguments<T>(Context, outcome);
-        Outcome = Polly.Outcome.ToObjectOutcome(outcome);
+        Outcome = outcome;
         IsHandled = await _handler.ShouldHandle(args).ConfigureAwait(Context.ContinueOnCapturedContext);
         TelemetryUtil.ReportExecutionAttempt(_telemetry, Context, outcome, AttemptNumber, ExecutionTime, IsHandled);
     }
diff --git a/src/Polly.Core/Hedging/HedgingResilienceStrategy.cs b/src/Polly.Core/Hedging/HedgingResilienceStrategy.cs
@@ -99,7 +99,7 @@ await HandleOnHedgingAsync(
                 continue;
             }
 
-            outcome = Outcome.FromObjectOutcome<T>(execution.Outcome);
+            outcome = execution.Outcome;
 
             if (!execution.IsHandled)
             {
diff --git a/src/Polly.Core/Outcome.cs b/src/Polly.Core/Outcome.cs
@@ -52,24 +52,4 @@ public static ValueTask<Outcome<TResult>> FromExceptionAsTask<TResult>(Exception
     internal static Outcome<VoidResult> Void => FromResult(VoidResult.Instance);
 
     internal static Outcome<VoidResult> FromException(Exception exception) => FromException<VoidResult>(exception);
-
-    internal static Outcome<object> ToObjectOutcome<T>(Outcome<T> outcome)
-    {
-        if (outcome.ExceptionDispatchInfo is null)
-        {
-            return FromResult((object?)outcome.Result);
-        }
-
-        return new Outcome<object>(outcome.ExceptionDispatchInfo);
-    }
-
-    internal static Outcome<T> FromObjectOutcome<T>(Outcome<object> outcome)
-    {
-        if (outcome.ExceptionDispatchInfo is null)
-        {
-            return FromResult((T)outcome.Result!);
-        }
-
-        return new Outcome<T>(outcome.ExceptionDispatchInfo);
-    }
 }
diff --git a/test/Polly.Core.Tests/CircuitBreaker/CircuitBreakerResilienceStrategyTests.cs b/test/Polly.Core.Tests/CircuitBreaker/CircuitBreakerResilienceStrategyTests.cs
@@ -44,7 +44,6 @@ public void Ctor_StateProvider_EnsureAttached()
         _options.StateProvider.IsInitialized.Should().BeTrue();
 
         _options.StateProvider.CircuitState.Should().Be(CircuitState.Closed);
-        _options.StateProvider.LastHandledOutcome.Should().Be(null);
     }
 
     [Fact]
diff --git a/test/Polly.Core.Tests/CircuitBreaker/CircuitBreakerStateProviderTests.cs b/test/Polly.Core.Tests/CircuitBreaker/CircuitBreakerStateProviderTests.cs
@@ -18,7 +18,6 @@ public void NotInitialized_EnsureDefaults()
         var provider = new CircuitBreakerStateProvider();
 
         provider.CircuitState.Should().Be(CircuitState.Closed);
-        provider.LastHandledOutcome.Should().Be(null);
     }
 
     [Fact]
@@ -36,10 +35,10 @@ await control
     public void Initialize_Twice_Throws()
     {
         var provider = new CircuitBreakerStateProvider();
-        provider.Initialize(() => CircuitState.Closed, () => null);
+        provider.Initialize(() => CircuitState.Closed);
 
         provider
-            .Invoking(c => c.Initialize(() => CircuitState.Closed, () => null))
+            .Invoking(c => c.Initialize(() => CircuitState.Closed))
             .Should()
             .Throw<InvalidOperationException>();
     }
@@ -49,24 +48,16 @@ public void Initialize_Ok()
     {
         var provider = new CircuitBreakerStateProvider();
         var stateCalled = false;
-        var exceptionCalled = false;
 
         provider.Initialize(
             () =>
             {
                 stateCalled = true;
                 return CircuitState.HalfOpen;
-            },
-            () =>
-            {
-                exceptionCalled = true;
-                return Outcome.FromException<object>(new InvalidOperationException());
             });
 
         provider.CircuitState.Should().Be(CircuitState.HalfOpen);
-        provider.LastHandledOutcome!.Value.Exception.Should().BeOfType<InvalidOperationException>();
 
         stateCalled.Should().BeTrue();
-        exceptionCalled.Should().BeTrue();
     }
 }
diff --git a/test/Polly.Core.Tests/Hedging/Controller/HedgingExecutionContextTests.cs b/test/Polly.Core.Tests/Hedging/Controller/HedgingExecutionContextTests.cs
@@ -104,7 +104,7 @@ public async Task TryWaitForCompletedExecutionAsync_FinishedTask_Ok()
         task.Should().NotBeNull();
         task!.ExecutionTaskSafe!.IsCompleted.Should().BeTrue();
 
-        Outcome.FromObjectOutcome<DisposableResult>(task.Outcome).Result!.Name.Should().Be("dummy");
+        task.Outcome.Result!.Name.Should().Be("dummy");
         task.AcceptOutcome();
         context.LoadedTasks.Should().Be(1);
     }
diff --git a/test/Polly.Core.Tests/Hedging/Controller/TaskExecutionTests.cs b/test/Polly.Core.Tests/Hedging/Controller/TaskExecutionTests.cs
@@ -58,7 +58,7 @@ await execution.InitializeAsync(HedgedTaskType.Primary, _snapshot,
             99);
 
         await execution.ExecutionTaskSafe!;
-        ((DisposableResult)execution.Outcome.Result!).Name.Should().Be(value);
+        execution.Outcome.Result!.Name.Should().Be(value);
         execution.IsHandled.Should().Be(handled);
         AssertPrimaryContext(execution.Context, execution);
 
@@ -98,7 +98,7 @@ public async Task Initialize_Secondary_Ok(string value, bool handled)
 
         await execution.ExecutionTaskSafe!;
 
-        ((DisposableResult)execution.Outcome.Result!).Name.Should().Be(value);
+        execution.Outcome.Result!.Name.Should().Be(value);
         execution.IsHandled.Should().Be(handled);
         AssertSecondaryContext(execution.Context, execution);
     }
diff --git a/test/Polly.Core.Tests/OutcomeTests.cs b/test/Polly.Core.Tests/OutcomeTests.cs
@@ -12,13 +12,6 @@ public void Ctor_Result_Ok()
         outcome.TryGetResult(out var result).Should().BeTrue();
         result.Should().Be(10);
         outcome.ToString().Should().Be("10");
-
-        var objectOutcome = Outcome.ToObjectOutcome(outcome);
-        objectOutcome.HasResult.Should().BeTrue();
-        objectOutcome.Exception.Should().BeNull();
-        objectOutcome.IsVoidResult.Should().BeFalse();
-        objectOutcome.TryGetResult(out var resultObj).Should().BeTrue();
-        resultObj.Should().Be(10);
     }
 
     [Fact]
@@ -31,13 +24,6 @@ public void Ctor_VoidResult_Ok()
         outcome.TryGetResult(out var result).Should().BeFalse();
         outcome.Result.Should().Be(VoidResult.Instance);
         outcome.ToString().Should().Be("void");
-
-        var objectOutcome = Outcome.ToObjectOutcome(outcome);
-        objectOutcome.HasResult.Should().BeTrue();
-        objectOutcome.Exception.Should().BeNull();
-        objectOutcome.IsVoidResult.Should().BeTrue();
-        objectOutcome.TryGetResult(out _).Should().BeFalse();
-        objectOutcome.Result.Should().Be(VoidResult.Instance);
     }
 
     [Fact]
@@ -50,13 +36,6 @@ public void Ctor_Exception_Ok()
         outcome.IsVoidResult.Should().BeFalse();
         outcome.TryGetResult(out var result).Should().BeFalse();
         outcome.ToString().Should().Be("Dummy message.");
-
-        var objectOutcome = Outcome.ToObjectOutcome(outcome);
-        objectOutcome.HasResult.Should().BeFalse();
-        objectOutcome.Exception.Should().NotBeNull();
-        objectOutcome.IsVoidResult.Should().BeFalse();
-        objectOutcome.TryGetResult(out _).Should().BeFalse();
-        objectOutcome.ExceptionDispatchInfo.Should().Be(outcome.ExceptionDispatchInfo);
     }
 
     [Fact]
diff --git a/test/Polly.TestUtils/TestUtilities.cs b/test/Polly.TestUtils/TestUtilities.cs
@@ -99,11 +99,18 @@ public static ResilienceContext WithVoidResultType(this ResilienceContext contex
 
     public static TelemetryEventArguments<object, object> AsObjectArguments<T, TArgs>(this TelemetryEventArguments<T, TArgs> args)
     {
+        Outcome<object>? outcome = args.Outcome switch
+        {
+            null => null,
+            { Exception: { } ex } => Outcome.FromException<object>(ex),
+            _ => Outcome.FromResult<object>(args.Outcome!.Value.Result),
+        };
+
         return new TelemetryEventArguments<object, object>(
                 args.Source,
                 args.Event,
                 args.Context,
                 args.Arguments!,
-                args.Outcome.HasValue ? Outcome.ToObjectOutcome(args.Outcome.Value) : null);
+                outcome);
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -6,17 +6,15 @@ namespace Polly.CircuitBreaker;`
`6`	`6`	`public sealed class CircuitBreakerStateProvider`
`7`	`7`	`{`
`8`	`8`	`private Func<CircuitState>? _circuitStateProvider;`
`9`		`- private Func<Outcome<object>?>? _lastHandledOutcomeProvider;`
`10`	`9`
`11`		`- internal void Initialize(Func<CircuitState> circuitStateProvider, Func<Outcome<object>?> lastHandledOutcomeProvider)`
	`10`	`+ internal void Initialize(Func<CircuitState> circuitStateProvider)`
`12`	`11`	`{`
`13`	`12`	`if (_circuitStateProvider != null)`
`14`	`13`	`{`
`15`	`14`	`throw new InvalidOperationException($"This instance of '{nameof(CircuitBreakerStateProvider)}' is already initialized and cannot be used in a different circuit-breaker strategy.");`
`16`	`15`	`}`
`17`	`16`
`18`	`17`	`_circuitStateProvider = circuitStateProvider;`
`19`		`- _lastHandledOutcomeProvider = lastHandledOutcomeProvider;`
`20`	`18`	`}`
`21`	`19`
`22`	`20`	`/// <summary>`
`@@ -32,11 +30,4 @@ internal void Initialize(Func<CircuitState> circuitStateProvider, Func<Outcome<o`
`32`	`30`	`/// Gets the state of the underlying circuit.`
`33`	`31`	`/// </summary>`
`34`	`32`	`public CircuitState CircuitState => _circuitStateProvider?.Invoke() ?? CircuitState.Closed;`
`35`		`-`
`36`		`- /// <summary>`
`37`		`- /// Gets the last outcome handled by the circuit-breaker.`
`38`		`- /// <remarks>`
`39`		`- /// This will be null if no exceptions or results have been handled by the circuit-breaker since the circuit last closed.</remarks>`
`40`		`- /// </summary>`
`41`		`- internal Outcome<object>? LastHandledOutcome => _lastHandledOutcomeProvider?.Invoke();`
`42`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ internal sealed class CircuitStateController<T> : IDisposable`
`18`	`18`	`private readonly TimeSpan _breakDuration;`
`19`	`19`	`private DateTimeOffset _blockedUntil;`
`20`	`20`	`private CircuitState _circuitState = CircuitState.Closed;`
`21`		`- private Outcome<object>? _lastOutcome;`
	`21`	`+ private Outcome<T>? _lastOutcome;`
`22`	`22`	`private BrokenCircuitException _breakingException = new();`
`23`	`23`	`private bool _disposed;`
`24`	`24`
`@@ -66,7 +66,7 @@ public Exception? LastException`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`
`69`		`- public Outcome<object>? LastHandledOutcome`
	`69`	`+ public Outcome<T>? LastHandledOutcome`
`70`	`70`	`{`
`71`	`71`	`get`
`72`	`72`	`{`
`@@ -290,17 +290,17 @@ private bool PermitHalfOpenCircuitTest_NeedsLock()`
`290`	`290`	`return false;`
`291`	`291`	`}`
`292`	`292`
`293`		`- private void SetLastHandledOutcome_NeedsLock<TResult>(Outcome<TResult> outcome)`
	`293`	`+ private void SetLastHandledOutcome_NeedsLock(Outcome<T> outcome)`
`294`	`294`	`{`
`295`		`- _lastOutcome = Outcome.ToObjectOutcome(outcome);`
	`295`	`+ _lastOutcome = outcome;`
`296`	`296`
`297`	`297`	`if (outcome.Exception is Exception exception)`
`298`	`298`	`{`
`299`	`299`	`_breakingException = new BrokenCircuitException(BrokenCircuitException.DefaultMessage, exception);`
`300`	`300`	`}`
`301`	`301`	`else if (outcome.TryGetResult(out var result))`
`302`	`302`	`{`
`303`		`- _breakingException = new BrokenCircuitException<TResult>(BrokenCircuitException.DefaultMessage, result!);`
	`303`	`+ _breakingException = new BrokenCircuitException<T>(BrokenCircuitException.DefaultMessage, result!);`
`304`	`304`	`}`
`305`	`305`	`}`
`306`	`306`
Original file line number	Diff line number	Diff line change
`@@ -156,9 +156,7 @@ private ExecutionInfo<T> CreateExecutionInfoWhenNoExecution()`
`156`	`156`	`var finishedExecution = _tasks.First(static t => t.ExecutionTaskSafe!.IsCompleted);`
`157`	`157`	`finishedExecution.AcceptOutcome();`
`158`	`158`
`159`		`- var outcome = Outcome.FromObjectOutcome<T>(finishedExecution.Outcome);`
`160`		`-`
`161`		`- return new ExecutionInfo<T>(null, false, outcome);`
	`159`	`+ return new ExecutionInfo<T>(null, false, finishedExecution.Outcome);`
`162`	`160`	`}`
`163`	`161`
`164`	`162`	`return new ExecutionInfo<T>(null, false, null);`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ public TaskExecution(HedgingHandler<T> handler, CancellationTokenSourcePool canc`
`49`	`49`	`/// </remarks>`
`50`	`50`	`public Task? ExecutionTaskSafe { get; private set; }`
`51`	`51`
`52`		`- public Outcome<object> Outcome { get; private set; }`
	`52`	`+ public Outcome<T> Outcome { get; private set; }`
`53`	`53`
`54`	`54`	`public bool IsHandled { get; private set; }`
`55`	`55`
`@@ -225,7 +225,7 @@ private async Task ExecutePrimaryActionAsync<TState>(Func<ResilienceContext, TSt`
`225`	`225`	`private async Task UpdateOutcomeAsync(Outcome<T> outcome)`
`226`	`226`	`{`
`227`	`227`	`var args = new HedgingPredicateArguments<T>(Context, outcome);`
`228`		`- Outcome = Polly.Outcome.ToObjectOutcome(outcome);`
	`228`	`+ Outcome = outcome;`
`229`	`229`	`IsHandled = await _handler.ShouldHandle(args).ConfigureAwait(Context.ContinueOnCapturedContext);`
`230`	`230`	`TelemetryUtil.ReportExecutionAttempt(_telemetry, Context, outcome, AttemptNumber, ExecutionTime, IsHandled);`
`231`	`231`	`}`
Original file line number	Diff line number	Diff line change
`@@ -99,7 +99,7 @@ await HandleOnHedgingAsync(`
`99`	`99`	`continue;`
`100`	`100`	`}`
`101`	`101`
`102`		`- outcome = Outcome.FromObjectOutcome<T>(execution.Outcome);`
	`102`	`+ outcome = execution.Outcome;`
`103`	`103`
`104`	`104`	`if (!execution.IsHandled)`
`105`	`105`	`{`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,6 @@ public void Ctor_StateProvider_EnsureAttached()`
`44`	`44`	`_options.StateProvider.IsInitialized.Should().BeTrue();`
`45`	`45`
`46`	`46`	`_options.StateProvider.CircuitState.Should().Be(CircuitState.Closed);`
`47`		`- _options.StateProvider.LastHandledOutcome.Should().Be(null);`
`48`	`47`	`}`
`49`	`48`
`50`	`49`	`[Fact]`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,6 @@ public void NotInitialized_EnsureDefaults()`
`18`	`18`	`var provider = new CircuitBreakerStateProvider();`
`19`	`19`
`20`	`20`	`provider.CircuitState.Should().Be(CircuitState.Closed);`
`21`		`- provider.LastHandledOutcome.Should().Be(null);`
`22`	`21`	`}`
`23`	`22`
`24`	`23`	`[Fact]`
`@@ -36,10 +35,10 @@ await control`
`36`	`35`	`public void Initialize_Twice_Throws()`
`37`	`36`	`{`
`38`	`37`	`var provider = new CircuitBreakerStateProvider();`
`39`		`- provider.Initialize(() => CircuitState.Closed, () => null);`
	`38`	`+ provider.Initialize(() => CircuitState.Closed);`
`40`	`39`
`41`	`40`	`provider`
`42`		`- .Invoking(c => c.Initialize(() => CircuitState.Closed, () => null))`
	`41`	`+ .Invoking(c => c.Initialize(() => CircuitState.Closed))`
`43`	`42`	`.Should()`
`44`	`43`	`.Throw<InvalidOperationException>();`
`45`	`44`	`}`
`@@ -49,24 +48,16 @@ public void Initialize_Ok()`
`49`	`48`	`{`
`50`	`49`	`var provider = new CircuitBreakerStateProvider();`
`51`	`50`	`var stateCalled = false;`
`52`		`- var exceptionCalled = false;`
`53`	`51`
`54`	`52`	`provider.Initialize(`
`55`	`53`	`() =>`
`56`	`54`	`{`
`57`	`55`	`stateCalled = true;`
`58`	`56`	`return CircuitState.HalfOpen;`
`59`		`- },`
`60`		`- () =>`
`61`		`- {`
`62`		`- exceptionCalled = true;`
`63`		`- return Outcome.FromException<object>(new InvalidOperationException());`
`64`	`57`	`});`
`65`	`58`
`66`	`59`	`provider.CircuitState.Should().Be(CircuitState.HalfOpen);`
`67`		`- provider.LastHandledOutcome!.Value.Exception.Should().BeOfType<InvalidOperationException>();`
`68`	`60`
`69`	`61`	`stateCalled.Should().BeTrue();`
`70`		`- exceptionCalled.Should().BeTrue();`
`71`	`62`	`}`
`72`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -104,7 +104,7 @@ public async Task TryWaitForCompletedExecutionAsync_FinishedTask_Ok()`
`104`	`104`	`task.Should().NotBeNull();`
`105`	`105`	`task!.ExecutionTaskSafe!.IsCompleted.Should().BeTrue();`
`106`	`106`
`107`		`- Outcome.FromObjectOutcome<DisposableResult>(task.Outcome).Result!.Name.Should().Be("dummy");`
	`107`	`+ task.Outcome.Result!.Name.Should().Be("dummy");`
`108`	`108`	`task.AcceptOutcome();`
`109`	`109`	`context.LoadedTasks.Should().Be(1);`
`110`	`110`	`}`
Original file line number	Diff line number	Diff line change
`@@ -99,11 +99,18 @@ public static ResilienceContext WithVoidResultType(this ResilienceContext contex`
`99`	`99`
`100`	`100`	`public static TelemetryEventArguments<object, object> AsObjectArguments<T, TArgs>(this TelemetryEventArguments<T, TArgs> args)`
`101`	`101`	`{`
	`102`	`+ Outcome<object>? outcome = args.Outcome switch`
	`103`	`+ {`
	`104`	`+ null => null,`
	`105`	`+ { Exception: { } ex } => Outcome.FromException<object>(ex),`
	`106`	`+ _ => Outcome.FromResult<object>(args.Outcome!.Value.Result),`
	`107`	`+ };`
	`108`	`+`
`102`	`109`	`return new TelemetryEventArguments<object, object>(`
`103`	`110`	`args.Source,`
`104`	`111`	`args.Event,`
`105`	`112`	`args.Context,`
`106`	`113`	`args.Arguments!,`
`107`		`- args.Outcome.HasValue ? Outcome.ToObjectOutcome(args.Outcome.Value) : null);`
	`114`	`+ outcome);`
`108`	`115`	`}`
`109`	`116`	`}`