Class TapOnFailureExtensionsAsync

Namespace: Trellis

Assembly: Trellis.Core.dll

Provides asynchronous extension methods for executing side effects on failed Results without changing the Result.

public static class TapOnFailureExtensionsAsync

Inheritance: object

TapOnFailureExtensionsAsync

Inherited Members: object.Equals(object)

object.Equals(object, object)

object.GetHashCode()

object.GetType()

object.MemberwiseClone()

object.ReferenceEquals(object, object)

object.ToString()

Examples

var ct = cancellationToken;
var result = await ValidateUserInputAsync(data)
    .TapOnFailureAsync(error => _logger.LogError("Validation failed: {Error}", error))
    .TapOnFailureAsync(error => SendErrorNotificationAsync(error, ct))
    .BindAsync(validData => ProcessDataAsync(validData));

Remarks

These methods enable async error handling patterns such as logging to external services, sending notifications, or recording metrics when operations fail.

All operations run on the failure track - they only execute when the Result has failed.

Methods

TapOnFailureAsync<TValue>(Task<Result<TValue>>, Action)

Asynchronously executes the given action if the result is a failure. Returns the original result unchanged.

[RailwayTrack(TrackBehavior.Failure)]
public static Task<Result<TValue>> TapOnFailureAsync<TValue>(this Task<Result<TValue>> resultTask, Action action)

Parameters

resultTask Task<Result<TValue>>: The task containing the result to tap.
action Action: The action to execute if the result is a failure.

Returns

Task<Result<TValue>>: The original result unchanged.

Type Parameters

TValue: Type of the result value.

TapOnFailureAsync<TValue>(Task<Result<TValue>>, Action<Error>)

Asynchronously executes the given action with the error if the result is a failure. Returns the original result unchanged.

[RailwayTrack(TrackBehavior.Failure)]
public static Task<Result<TValue>> TapOnFailureAsync<TValue>(this Task<Result<TValue>> resultTask, Action<Error> action)

Parameters

resultTask Task<Result<TValue>>: The task containing the result to tap.
action Action<Error>: The action to execute with the error if the result is a failure.

Returns

Task<Result<TValue>>: The original result unchanged.

Type Parameters

TValue: Type of the result value.

TapOnFailureAsync<TValue>(Task<Result<TValue>>, Func<Task>)

Asynchronously executes the given async action if the result is a failure. Returns the original result unchanged.

[RailwayTrack(TrackBehavior.Failure)]
public static Task<Result<TValue>> TapOnFailureAsync<TValue>(this Task<Result<TValue>> resultTask, Func<Task> func)

Parameters

resultTask Task<Result<TValue>>: The task containing the result to tap.
func Func<Task>: The async action to execute if the result is a failure.

Returns

Task<Result<TValue>>: The original result unchanged.

Type Parameters

TValue: Type of the result value.

TapOnFailureAsync<TValue>(Task<Result<TValue>>, Func<Error, Task>)

Asynchronously executes the given async action with the error if the result is a failure. Returns the original result unchanged.

[RailwayTrack(TrackBehavior.Failure)]
public static Task<Result<TValue>> TapOnFailureAsync<TValue>(this Task<Result<TValue>> resultTask, Func<Error, Task> func)

Parameters

resultTask Task<Result<TValue>>: The task containing the result to tap.
func Func<Error, Task>: The async action to execute with the error if the result is a failure.

Returns

Task<Result<TValue>>: The original result unchanged.

Type Parameters

TValue: Type of the result value.

TapOnFailureAsync<TValue>(ValueTask<Result<TValue>>, Action)

Asynchronously executes the given action if the result is a failure. Returns the original result unchanged.

[RailwayTrack(TrackBehavior.Failure)]
public static ValueTask<Result<TValue>> TapOnFailureAsync<TValue>(this ValueTask<Result<TValue>> resultTask, Action action)

Parameters

resultTask ValueTask<Result<TValue>>: The ValueTask containing the result to tap.
action Action: The action to execute if the result is a failure.

Returns

ValueTask<Result<TValue>>: The original result unchanged.

Type Parameters

TValue: Type of the result value.

TapOnFailureAsync<TValue>(ValueTask<Result<TValue>>, Action<Error>)

Asynchronously executes the given action with the error if the result is a failure. Returns the original result unchanged.

[RailwayTrack(TrackBehavior.Failure)]
public static ValueTask<Result<TValue>> TapOnFailureAsync<TValue>(this ValueTask<Result<TValue>> resultTask, Action<Error> action)

Parameters

resultTask ValueTask<Result<TValue>>: The ValueTask containing the result to tap.
action Action<Error>: The action to execute with the error if the result is a failure.

Returns

ValueTask<Result<TValue>>: The original result unchanged.

Type Parameters

TValue: Type of the result value.

TapOnFailureAsync<TValue>(ValueTask<Result<TValue>>, Func<ValueTask>)

Asynchronously executes the given async action if the result is a failure. Returns the original result unchanged.

[RailwayTrack(TrackBehavior.Failure)]
public static ValueTask<Result<TValue>> TapOnFailureAsync<TValue>(this ValueTask<Result<TValue>> resultTask, Func<ValueTask> func)

Parameters

resultTask ValueTask<Result<TValue>>: The ValueTask containing the result to tap.
func Func<ValueTask>: The async action to execute if the result is a failure.

Returns

ValueTask<Result<TValue>>: The original result unchanged.

Type Parameters

TValue: Type of the result value.

TapOnFailureAsync<TValue>(ValueTask<Result<TValue>>, Func<Error, ValueTask>)

Asynchronously executes the given async action with the error if the result is a failure. Returns the original result unchanged.

[RailwayTrack(TrackBehavior.Failure)]
public static ValueTask<Result<TValue>> TapOnFailureAsync<TValue>(this ValueTask<Result<TValue>> resultTask, Func<Error, ValueTask> func)

Parameters

resultTask ValueTask<Result<TValue>>: The ValueTask containing the result to tap.
func Func<Error, ValueTask>: The async action to execute with the error if the result is a failure.

Returns

ValueTask<Result<TValue>>: The original result unchanged.

Type Parameters

TValue: Type of the result value.

TapOnFailureAsync<TValue>(Result<TValue>, Func<Task>)

Asynchronously executes the given async action if the result is a failure. Returns the original result unchanged.

[RailwayTrack(TrackBehavior.Failure)]
public static Task<Result<TValue>> TapOnFailureAsync<TValue>(this Result<TValue> result, Func<Task> func)

Parameters

result Result<TValue>: The result to tap.
func Func<Task>: The async action to execute if the result is a failure.

Returns

Task<Result<TValue>>: The original result unchanged.

Type Parameters

TValue: Type of the result value.

Remarks

OverloadResolutionPriorityAttribute resolves the historical CS0121 ambiguity against the sibling ValueTask-delegate overload on the same sync Result<TValue> receiver for inline async lambdas.

TapOnFailureAsync<TValue>(Result<TValue>, Func<ValueTask>)

Asynchronously executes the given async action if the result is a failure. Returns the original result unchanged.

[RailwayTrack(TrackBehavior.Failure)]
public static ValueTask<Result<TValue>> TapOnFailureAsync<TValue>(this Result<TValue> result, Func<ValueTask> func)

Parameters

result Result<TValue>: The result to tap.
func Func<ValueTask>: The async action to execute if the result is a failure.

Returns

ValueTask<Result<TValue>>: The original result unchanged.

Type Parameters

TValue: Type of the result value.

TapOnFailureAsync<TValue>(Result<TValue>, Func<Error, Task>)

Asynchronously executes the given async action with the error if the result is a failure. Returns the original result unchanged.

[RailwayTrack(TrackBehavior.Failure)]
public static Task<Result<TValue>> TapOnFailureAsync<TValue>(this Result<TValue> result, Func<Error, Task> func)

Parameters

result Result<TValue>: The result to tap.
func Func<Error, Task>: The async action to execute with the error if the result is a failure.

Returns

Task<Result<TValue>>: The original result unchanged.

Type Parameters

TValue: Type of the result value.

Remarks

OverloadResolutionPriorityAttribute resolves the historical CS0121 ambiguity against the sibling ValueTask-delegate overload on the same sync Result<TValue> receiver for inline async lambdas.

TapOnFailureAsync<TValue>(Result<TValue>, Func<Error, ValueTask>)

Asynchronously executes the given async action with the error if the result is a failure. Returns the original result unchanged.

[RailwayTrack(TrackBehavior.Failure)]
public static ValueTask<Result<TValue>> TapOnFailureAsync<TValue>(this Result<TValue> result, Func<Error, ValueTask> func)

Parameters

result Result<TValue>: The result to tap.
func Func<Error, ValueTask>: The async action to execute with the error if the result is a failure.

Returns

ValueTask<Result<TValue>>: The original result unchanged.

Type Parameters

TValue: Type of the result value.

TapOnFailureAsync<T1, T2>(Task<Result<(T1, T2)>>, Action)

Executes a synchronous side effect action when an asynchronous 2-element tuple result fails.

public static Task<Result<(T1, T2)>> TapOnFailureAsync<T1, T2>(this Task<Result<(T1, T2)>> resultTask, Action action)

Parameters

resultTask Task<Result<(T1, T2)>>: The task representing the result containing a 2-element tuple.
action Action: The side effect action to execute on failure.

Returns

Task<Result<(T1, T2)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.

TapOnFailureAsync<T1, T2>(Task<Result<(T1, T2)>>, Action<Error>)

Executes a synchronous side effect action with the error when an asynchronous 2-element tuple result fails.

public static Task<Result<(T1, T2)>> TapOnFailureAsync<T1, T2>(this Task<Result<(T1, T2)>> resultTask, Action<Error> action)

Parameters

resultTask Task<Result<(T1, T2)>>: The task representing the result containing a 2-element tuple.
action Action<Error>: The side effect action to execute with the error on failure.

Returns

Task<Result<(T1, T2)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.

TapOnFailureAsync<T1, T2>(Task<Result<(T1, T2)>>, Func<Task>)

Executes an asynchronous side effect action when an asynchronous 2-element tuple result fails.

public static Task<Result<(T1, T2)>> TapOnFailureAsync<T1, T2>(this Task<Result<(T1, T2)>> resultTask, Func<Task> func)

Parameters

resultTask Task<Result<(T1, T2)>>: The task representing the result containing a 2-element tuple.
func Func<Task>: The async side effect function to execute on failure.

Returns

Task<Result<(T1, T2)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.

TapOnFailureAsync<T1, T2>(Task<Result<(T1, T2)>>, Func<Error, Task>)

Executes an asynchronous side effect action with the error when an asynchronous 2-element tuple result fails.

public static Task<Result<(T1, T2)>> TapOnFailureAsync<T1, T2>(this Task<Result<(T1, T2)>> resultTask, Func<Error, Task> func)

Parameters

resultTask Task<Result<(T1, T2)>>: The task representing the result containing a 2-element tuple.
func Func<Error, Task>: The async side effect function to execute with the error on failure.

Returns

Task<Result<(T1, T2)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.

TapOnFailureAsync<T1, T2>(ValueTask<Result<(T1, T2)>>, Action)

Executes a synchronous side effect action when an asynchronous 2-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2)>> TapOnFailureAsync<T1, T2>(this ValueTask<Result<(T1, T2)>> resultTask, Action action)

Parameters

resultTask ValueTask<Result<(T1, T2)>>: The ValueTask representing the result containing a 2-element tuple.
action Action: The side effect action to execute on failure.

Returns

ValueTask<Result<(T1, T2)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.

TapOnFailureAsync<T1, T2>(ValueTask<Result<(T1, T2)>>, Action<Error>)

Executes a synchronous side effect action with the error when an asynchronous 2-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2)>> TapOnFailureAsync<T1, T2>(this ValueTask<Result<(T1, T2)>> resultTask, Action<Error> action)

Parameters

resultTask ValueTask<Result<(T1, T2)>>: The ValueTask representing the result containing a 2-element tuple.
action Action<Error>: The side effect action to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.

TapOnFailureAsync<T1, T2>(ValueTask<Result<(T1, T2)>>, Func<ValueTask>)

Executes an asynchronous side effect action when an asynchronous 2-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2)>> TapOnFailureAsync<T1, T2>(this ValueTask<Result<(T1, T2)>> resultTask, Func<ValueTask> func)

Parameters

resultTask ValueTask<Result<(T1, T2)>>: The ValueTask representing the result containing a 2-element tuple.
func Func<ValueTask>: The async side effect function to execute on failure.

Returns

ValueTask<Result<(T1, T2)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.

TapOnFailureAsync<T1, T2>(ValueTask<Result<(T1, T2)>>, Func<Error, ValueTask>)

Executes an asynchronous side effect action with the error when an asynchronous 2-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2)>> TapOnFailureAsync<T1, T2>(this ValueTask<Result<(T1, T2)>> resultTask, Func<Error, ValueTask> func)

Parameters

resultTask ValueTask<Result<(T1, T2)>>: The ValueTask representing the result containing a 2-element tuple.
func Func<Error, ValueTask>: The async side effect function to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.

TapOnFailureAsync<T1, T2>(Result<(T1, T2)>, Func<Task>)

Executes an asynchronous side effect action when a synchronous 2-element tuple result fails.

public static Task<Result<(T1, T2)>> TapOnFailureAsync<T1, T2>(this Result<(T1, T2)> result, Func<Task> func)

Parameters

result Result<(T1, T2)>: The result containing a 2-element tuple.
func Func<Task>: The async side effect function to execute on failure.

Returns

Task<Result<(T1, T2)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.

TapOnFailureAsync<T1, T2>(Result<(T1, T2)>, Func<ValueTask>)

Executes an asynchronous side effect action when a synchronous 2-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2)>> TapOnFailureAsync<T1, T2>(this Result<(T1, T2)> result, Func<ValueTask> func)

Parameters

result Result<(T1, T2)>: The result containing a 2-element tuple.
func Func<ValueTask>: The async side effect function to execute on failure.

Returns

ValueTask<Result<(T1, T2)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.

TapOnFailureAsync<T1, T2>(Result<(T1, T2)>, Func<Error, Task>)

Executes an asynchronous side effect action with the error when a synchronous 2-element tuple result fails.

public static Task<Result<(T1, T2)>> TapOnFailureAsync<T1, T2>(this Result<(T1, T2)> result, Func<Error, Task> func)

Parameters

result Result<(T1, T2)>: The result containing a 2-element tuple.
func Func<Error, Task>: The async side effect function to execute with the error on failure.

Returns

Task<Result<(T1, T2)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.

TapOnFailureAsync<T1, T2>(Result<(T1, T2)>, Func<Error, ValueTask>)

Executes an asynchronous side effect action with the error when a synchronous 2-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2)>> TapOnFailureAsync<T1, T2>(this Result<(T1, T2)> result, Func<Error, ValueTask> func)

Parameters

result Result<(T1, T2)>: The result containing a 2-element tuple.
func Func<Error, ValueTask>: The async side effect function to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.

TapOnFailureAsync<T1, T2, T3>(Task<Result<(T1, T2, T3)>>, Action)

Executes a synchronous side effect action when an asynchronous 3-element tuple result fails.

public static Task<Result<(T1, T2, T3)>> TapOnFailureAsync<T1, T2, T3>(this Task<Result<(T1, T2, T3)>> resultTask, Action action)

Parameters

resultTask Task<Result<(T1, T2, T3)>>: The task representing the result containing a 3-element tuple.
action Action: The side effect action to execute on failure.

Returns

Task<Result<(T1, T2, T3)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.

TapOnFailureAsync<T1, T2, T3>(Task<Result<(T1, T2, T3)>>, Action<Error>)

Executes a synchronous side effect action with the error when an asynchronous 3-element tuple result fails.

public static Task<Result<(T1, T2, T3)>> TapOnFailureAsync<T1, T2, T3>(this Task<Result<(T1, T2, T3)>> resultTask, Action<Error> action)

Parameters

resultTask Task<Result<(T1, T2, T3)>>: The task representing the result containing a 3-element tuple.
action Action<Error>: The side effect action to execute with the error on failure.

Returns

Task<Result<(T1, T2, T3)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.

TapOnFailureAsync<T1, T2, T3>(Task<Result<(T1, T2, T3)>>, Func<Task>)

Executes an asynchronous side effect action when an asynchronous 3-element tuple result fails.

public static Task<Result<(T1, T2, T3)>> TapOnFailureAsync<T1, T2, T3>(this Task<Result<(T1, T2, T3)>> resultTask, Func<Task> func)

Parameters

resultTask Task<Result<(T1, T2, T3)>>: The task representing the result containing a 3-element tuple.
func Func<Task>: The async side effect function to execute on failure.

Returns

Task<Result<(T1, T2, T3)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.

TapOnFailureAsync<T1, T2, T3>(Task<Result<(T1, T2, T3)>>, Func<Error, Task>)

Executes an asynchronous side effect action with the error when an asynchronous 3-element tuple result fails.

public static Task<Result<(T1, T2, T3)>> TapOnFailureAsync<T1, T2, T3>(this Task<Result<(T1, T2, T3)>> resultTask, Func<Error, Task> func)

Parameters

resultTask Task<Result<(T1, T2, T3)>>: The task representing the result containing a 3-element tuple.
func Func<Error, Task>: The async side effect function to execute with the error on failure.

Returns

Task<Result<(T1, T2, T3)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.

TapOnFailureAsync<T1, T2, T3>(ValueTask<Result<(T1, T2, T3)>>, Action)

Executes a synchronous side effect action when an asynchronous 3-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3)>> TapOnFailureAsync<T1, T2, T3>(this ValueTask<Result<(T1, T2, T3)>> resultTask, Action action)

Parameters

resultTask ValueTask<Result<(T1, T2, T3)>>: The ValueTask representing the result containing a 3-element tuple.
action Action: The side effect action to execute on failure.

Returns

ValueTask<Result<(T1, T2, T3)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.

TapOnFailureAsync<T1, T2, T3>(ValueTask<Result<(T1, T2, T3)>>, Action<Error>)

Executes a synchronous side effect action with the error when an asynchronous 3-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3)>> TapOnFailureAsync<T1, T2, T3>(this ValueTask<Result<(T1, T2, T3)>> resultTask, Action<Error> action)

Parameters

resultTask ValueTask<Result<(T1, T2, T3)>>: The ValueTask representing the result containing a 3-element tuple.
action Action<Error>: The side effect action to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2, T3)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.

TapOnFailureAsync<T1, T2, T3>(ValueTask<Result<(T1, T2, T3)>>, Func<ValueTask>)

Executes an asynchronous side effect action when an asynchronous 3-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3)>> TapOnFailureAsync<T1, T2, T3>(this ValueTask<Result<(T1, T2, T3)>> resultTask, Func<ValueTask> func)

Parameters

resultTask ValueTask<Result<(T1, T2, T3)>>: The ValueTask representing the result containing a 3-element tuple.
func Func<ValueTask>: The async side effect function to execute on failure.

Returns

ValueTask<Result<(T1, T2, T3)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.

TapOnFailureAsync<T1, T2, T3>(ValueTask<Result<(T1, T2, T3)>>, Func<Error, ValueTask>)

Executes an asynchronous side effect action with the error when an asynchronous 3-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3)>> TapOnFailureAsync<T1, T2, T3>(this ValueTask<Result<(T1, T2, T3)>> resultTask, Func<Error, ValueTask> func)

Parameters

resultTask ValueTask<Result<(T1, T2, T3)>>: The ValueTask representing the result containing a 3-element tuple.
func Func<Error, ValueTask>: The async side effect function to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2, T3)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.

TapOnFailureAsync<T1, T2, T3>(Result<(T1, T2, T3)>, Func<Task>)

Executes an asynchronous side effect action when a synchronous 3-element tuple result fails.

public static Task<Result<(T1, T2, T3)>> TapOnFailureAsync<T1, T2, T3>(this Result<(T1, T2, T3)> result, Func<Task> func)

Parameters

result Result<(T1, T2, T3)>: The result containing a 3-element tuple.
func Func<Task>: The async side effect function to execute on failure.

Returns

Task<Result<(T1, T2, T3)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.

TapOnFailureAsync<T1, T2, T3>(Result<(T1, T2, T3)>, Func<ValueTask>)

Executes an asynchronous side effect action when a synchronous 3-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3)>> TapOnFailureAsync<T1, T2, T3>(this Result<(T1, T2, T3)> result, Func<ValueTask> func)

Parameters

result Result<(T1, T2, T3)>: The result containing a 3-element tuple.
func Func<ValueTask>: The async side effect function to execute on failure.

Returns

ValueTask<Result<(T1, T2, T3)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.

TapOnFailureAsync<T1, T2, T3>(Result<(T1, T2, T3)>, Func<Error, Task>)

Executes an asynchronous side effect action with the error when a synchronous 3-element tuple result fails.

public static Task<Result<(T1, T2, T3)>> TapOnFailureAsync<T1, T2, T3>(this Result<(T1, T2, T3)> result, Func<Error, Task> func)

Parameters

result Result<(T1, T2, T3)>: The result containing a 3-element tuple.
func Func<Error, Task>: The async side effect function to execute with the error on failure.

Returns

Task<Result<(T1, T2, T3)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.

TapOnFailureAsync<T1, T2, T3>(Result<(T1, T2, T3)>, Func<Error, ValueTask>)

Executes an asynchronous side effect action with the error when a synchronous 3-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3)>> TapOnFailureAsync<T1, T2, T3>(this Result<(T1, T2, T3)> result, Func<Error, ValueTask> func)

Parameters

result Result<(T1, T2, T3)>: The result containing a 3-element tuple.
func Func<Error, ValueTask>: The async side effect function to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2, T3)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4>(Task<Result<(T1, T2, T3, T4)>>, Action)

Executes a synchronous side effect action when an asynchronous 4-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4)>> TapOnFailureAsync<T1, T2, T3, T4>(this Task<Result<(T1, T2, T3, T4)>> resultTask, Action action)

Parameters

resultTask Task<Result<(T1, T2, T3, T4)>>: The task representing the result containing a 4-element tuple.
action Action: The side effect action to execute on failure.

Returns

Task<Result<(T1, T2, T3, T4)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4>(Task<Result<(T1, T2, T3, T4)>>, Action<Error>)

Executes a synchronous side effect action with the error when an asynchronous 4-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4)>> TapOnFailureAsync<T1, T2, T3, T4>(this Task<Result<(T1, T2, T3, T4)>> resultTask, Action<Error> action)

Parameters

resultTask Task<Result<(T1, T2, T3, T4)>>: The task representing the result containing a 4-element tuple.
action Action<Error>: The side effect action to execute with the error on failure.

Returns

Task<Result<(T1, T2, T3, T4)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4>(Task<Result<(T1, T2, T3, T4)>>, Func<Task>)

Executes an asynchronous side effect action when an asynchronous 4-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4)>> TapOnFailureAsync<T1, T2, T3, T4>(this Task<Result<(T1, T2, T3, T4)>> resultTask, Func<Task> func)

Parameters

resultTask Task<Result<(T1, T2, T3, T4)>>: The task representing the result containing a 4-element tuple.
func Func<Task>: The async side effect function to execute on failure.

Returns

Task<Result<(T1, T2, T3, T4)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4>(Task<Result<(T1, T2, T3, T4)>>, Func<Error, Task>)

Executes an asynchronous side effect action with the error when an asynchronous 4-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4)>> TapOnFailureAsync<T1, T2, T3, T4>(this Task<Result<(T1, T2, T3, T4)>> resultTask, Func<Error, Task> func)

Parameters

resultTask Task<Result<(T1, T2, T3, T4)>>: The task representing the result containing a 4-element tuple.
func Func<Error, Task>: The async side effect function to execute with the error on failure.

Returns

Task<Result<(T1, T2, T3, T4)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4>(ValueTask<Result<(T1, T2, T3, T4)>>, Action)

Executes a synchronous side effect action when an asynchronous 4-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4)>> TapOnFailureAsync<T1, T2, T3, T4>(this ValueTask<Result<(T1, T2, T3, T4)>> resultTask, Action action)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4)>>: The ValueTask representing the result containing a 4-element tuple.
action Action: The side effect action to execute on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4>(ValueTask<Result<(T1, T2, T3, T4)>>, Action<Error>)

Executes a synchronous side effect action with the error when an asynchronous 4-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4)>> TapOnFailureAsync<T1, T2, T3, T4>(this ValueTask<Result<(T1, T2, T3, T4)>> resultTask, Action<Error> action)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4)>>: The ValueTask representing the result containing a 4-element tuple.
action Action<Error>: The side effect action to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4>(ValueTask<Result<(T1, T2, T3, T4)>>, Func<ValueTask>)

Executes an asynchronous side effect action when an asynchronous 4-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4)>> TapOnFailureAsync<T1, T2, T3, T4>(this ValueTask<Result<(T1, T2, T3, T4)>> resultTask, Func<ValueTask> func)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4)>>: The ValueTask representing the result containing a 4-element tuple.
func Func<ValueTask>: The async side effect function to execute on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4>(ValueTask<Result<(T1, T2, T3, T4)>>, Func<Error, ValueTask>)

Executes an asynchronous side effect action with the error when an asynchronous 4-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4)>> TapOnFailureAsync<T1, T2, T3, T4>(this ValueTask<Result<(T1, T2, T3, T4)>> resultTask, Func<Error, ValueTask> func)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4)>>: The ValueTask representing the result containing a 4-element tuple.
func Func<Error, ValueTask>: The async side effect function to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4>(Result<(T1, T2, T3, T4)>, Func<Task>)

Executes an asynchronous side effect action when a synchronous 4-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4)>> TapOnFailureAsync<T1, T2, T3, T4>(this Result<(T1, T2, T3, T4)> result, Func<Task> func)

Parameters

result Result<(T1, T2, T3, T4)>: The result containing a 4-element tuple.
func Func<Task>: The async side effect function to execute on failure.

Returns

Task<Result<(T1, T2, T3, T4)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4>(Result<(T1, T2, T3, T4)>, Func<ValueTask>)

Executes an asynchronous side effect action when a synchronous 4-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4)>> TapOnFailureAsync<T1, T2, T3, T4>(this Result<(T1, T2, T3, T4)> result, Func<ValueTask> func)

Parameters

result Result<(T1, T2, T3, T4)>: The result containing a 4-element tuple.
func Func<ValueTask>: The async side effect function to execute on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4>(Result<(T1, T2, T3, T4)>, Func<Error, Task>)

Executes an asynchronous side effect action with the error when a synchronous 4-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4)>> TapOnFailureAsync<T1, T2, T3, T4>(this Result<(T1, T2, T3, T4)> result, Func<Error, Task> func)

Parameters

result Result<(T1, T2, T3, T4)>: The result containing a 4-element tuple.
func Func<Error, Task>: The async side effect function to execute with the error on failure.

Returns

Task<Result<(T1, T2, T3, T4)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4>(Result<(T1, T2, T3, T4)>, Func<Error, ValueTask>)

Executes an asynchronous side effect action with the error when a synchronous 4-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4)>> TapOnFailureAsync<T1, T2, T3, T4>(this Result<(T1, T2, T3, T4)> result, Func<Error, ValueTask> func)

Parameters

result Result<(T1, T2, T3, T4)>: The result containing a 4-element tuple.
func Func<Error, ValueTask>: The async side effect function to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5>(Task<Result<(T1, T2, T3, T4, T5)>>, Action)

Executes a synchronous side effect action when an asynchronous 5-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5)>> TapOnFailureAsync<T1, T2, T3, T4, T5>(this Task<Result<(T1, T2, T3, T4, T5)>> resultTask, Action action)

Parameters

resultTask Task<Result<(T1, T2, T3, T4, T5)>>: The task representing the result containing a 5-element tuple.
action Action: The side effect action to execute on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5>(Task<Result<(T1, T2, T3, T4, T5)>>, Action<Error>)

Executes a synchronous side effect action with the error when an asynchronous 5-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5)>> TapOnFailureAsync<T1, T2, T3, T4, T5>(this Task<Result<(T1, T2, T3, T4, T5)>> resultTask, Action<Error> action)

Parameters

resultTask Task<Result<(T1, T2, T3, T4, T5)>>: The task representing the result containing a 5-element tuple.
action Action<Error>: The side effect action to execute with the error on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5>(Task<Result<(T1, T2, T3, T4, T5)>>, Func<Task>)

Executes an asynchronous side effect action when an asynchronous 5-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5)>> TapOnFailureAsync<T1, T2, T3, T4, T5>(this Task<Result<(T1, T2, T3, T4, T5)>> resultTask, Func<Task> func)

Parameters

resultTask Task<Result<(T1, T2, T3, T4, T5)>>: The task representing the result containing a 5-element tuple.
func Func<Task>: The async side effect function to execute on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5>(Task<Result<(T1, T2, T3, T4, T5)>>, Func<Error, Task>)

Executes an asynchronous side effect action with the error when an asynchronous 5-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5)>> TapOnFailureAsync<T1, T2, T3, T4, T5>(this Task<Result<(T1, T2, T3, T4, T5)>> resultTask, Func<Error, Task> func)

Parameters

resultTask Task<Result<(T1, T2, T3, T4, T5)>>: The task representing the result containing a 5-element tuple.
func Func<Error, Task>: The async side effect function to execute with the error on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5>(ValueTask<Result<(T1, T2, T3, T4, T5)>>, Action)

Executes a synchronous side effect action when an asynchronous 5-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5)>> TapOnFailureAsync<T1, T2, T3, T4, T5>(this ValueTask<Result<(T1, T2, T3, T4, T5)>> resultTask, Action action)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4, T5)>>: The ValueTask representing the result containing a 5-element tuple.
action Action: The side effect action to execute on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5>(ValueTask<Result<(T1, T2, T3, T4, T5)>>, Action<Error>)

Executes a synchronous side effect action with the error when an asynchronous 5-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5)>> TapOnFailureAsync<T1, T2, T3, T4, T5>(this ValueTask<Result<(T1, T2, T3, T4, T5)>> resultTask, Action<Error> action)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4, T5)>>: The ValueTask representing the result containing a 5-element tuple.
action Action<Error>: The side effect action to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5>(ValueTask<Result<(T1, T2, T3, T4, T5)>>, Func<ValueTask>)

Executes an asynchronous side effect action when an asynchronous 5-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5)>> TapOnFailureAsync<T1, T2, T3, T4, T5>(this ValueTask<Result<(T1, T2, T3, T4, T5)>> resultTask, Func<ValueTask> func)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4, T5)>>: The ValueTask representing the result containing a 5-element tuple.
func Func<ValueTask>: The async side effect function to execute on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5>(ValueTask<Result<(T1, T2, T3, T4, T5)>>, Func<Error, ValueTask>)

Executes an asynchronous side effect action with the error when an asynchronous 5-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5)>> TapOnFailureAsync<T1, T2, T3, T4, T5>(this ValueTask<Result<(T1, T2, T3, T4, T5)>> resultTask, Func<Error, ValueTask> func)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4, T5)>>: The ValueTask representing the result containing a 5-element tuple.
func Func<Error, ValueTask>: The async side effect function to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5>(Result<(T1, T2, T3, T4, T5)>, Func<Task>)

Executes an asynchronous side effect action when a synchronous 5-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5)>> TapOnFailureAsync<T1, T2, T3, T4, T5>(this Result<(T1, T2, T3, T4, T5)> result, Func<Task> func)

Parameters

result Result<(T1, T2, T3, T4, T5)>: The result containing a 5-element tuple.
func Func<Task>: The async side effect function to execute on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5>(Result<(T1, T2, T3, T4, T5)>, Func<ValueTask>)

Executes an asynchronous side effect action when a synchronous 5-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5)>> TapOnFailureAsync<T1, T2, T3, T4, T5>(this Result<(T1, T2, T3, T4, T5)> result, Func<ValueTask> func)

Parameters

result Result<(T1, T2, T3, T4, T5)>: The result containing a 5-element tuple.
func Func<ValueTask>: The async side effect function to execute on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5>(Result<(T1, T2, T3, T4, T5)>, Func<Error, Task>)

Executes an asynchronous side effect action with the error when a synchronous 5-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5)>> TapOnFailureAsync<T1, T2, T3, T4, T5>(this Result<(T1, T2, T3, T4, T5)> result, Func<Error, Task> func)

Parameters

result Result<(T1, T2, T3, T4, T5)>: The result containing a 5-element tuple.
func Func<Error, Task>: The async side effect function to execute with the error on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5>(Result<(T1, T2, T3, T4, T5)>, Func<Error, ValueTask>)

Executes an asynchronous side effect action with the error when a synchronous 5-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5)>> TapOnFailureAsync<T1, T2, T3, T4, T5>(this Result<(T1, T2, T3, T4, T5)> result, Func<Error, ValueTask> func)

Parameters

result Result<(T1, T2, T3, T4, T5)>: The result containing a 5-element tuple.
func Func<Error, ValueTask>: The async side effect function to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(Task<Result<(T1, T2, T3, T4, T5, T6)>>, Action)

Executes a synchronous side effect action when an asynchronous 6-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(this Task<Result<(T1, T2, T3, T4, T5, T6)>> resultTask, Action action)

Parameters

resultTask Task<Result<(T1, T2, T3, T4, T5, T6)>>: The task representing the result containing a 6-element tuple.
action Action: The side effect action to execute on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(Task<Result<(T1, T2, T3, T4, T5, T6)>>, Action<Error>)

Executes a synchronous side effect action with the error when an asynchronous 6-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(this Task<Result<(T1, T2, T3, T4, T5, T6)>> resultTask, Action<Error> action)

Parameters

resultTask Task<Result<(T1, T2, T3, T4, T5, T6)>>: The task representing the result containing a 6-element tuple.
action Action<Error>: The side effect action to execute with the error on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(Task<Result<(T1, T2, T3, T4, T5, T6)>>, Func<Task>)

Executes an asynchronous side effect action when an asynchronous 6-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(this Task<Result<(T1, T2, T3, T4, T5, T6)>> resultTask, Func<Task> func)

Parameters

resultTask Task<Result<(T1, T2, T3, T4, T5, T6)>>: The task representing the result containing a 6-element tuple.
func Func<Task>: The async side effect function to execute on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(Task<Result<(T1, T2, T3, T4, T5, T6)>>, Func<Error, Task>)

Executes an asynchronous side effect action with the error when an asynchronous 6-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(this Task<Result<(T1, T2, T3, T4, T5, T6)>> resultTask, Func<Error, Task> func)

Parameters

resultTask Task<Result<(T1, T2, T3, T4, T5, T6)>>: The task representing the result containing a 6-element tuple.
func Func<Error, Task>: The async side effect function to execute with the error on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(ValueTask<Result<(T1, T2, T3, T4, T5, T6)>>, Action)

Executes a synchronous side effect action when an asynchronous 6-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(this ValueTask<Result<(T1, T2, T3, T4, T5, T6)>> resultTask, Action action)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4, T5, T6)>>: The ValueTask representing the result containing a 6-element tuple.
action Action: The side effect action to execute on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(ValueTask<Result<(T1, T2, T3, T4, T5, T6)>>, Action<Error>)

Executes a synchronous side effect action with the error when an asynchronous 6-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(this ValueTask<Result<(T1, T2, T3, T4, T5, T6)>> resultTask, Action<Error> action)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4, T5, T6)>>: The ValueTask representing the result containing a 6-element tuple.
action Action<Error>: The side effect action to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(ValueTask<Result<(T1, T2, T3, T4, T5, T6)>>, Func<ValueTask>)

Executes an asynchronous side effect action when an asynchronous 6-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(this ValueTask<Result<(T1, T2, T3, T4, T5, T6)>> resultTask, Func<ValueTask> func)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4, T5, T6)>>: The ValueTask representing the result containing a 6-element tuple.
func Func<ValueTask>: The async side effect function to execute on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(ValueTask<Result<(T1, T2, T3, T4, T5, T6)>>, Func<Error, ValueTask>)

Executes an asynchronous side effect action with the error when an asynchronous 6-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(this ValueTask<Result<(T1, T2, T3, T4, T5, T6)>> resultTask, Func<Error, ValueTask> func)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4, T5, T6)>>: The ValueTask representing the result containing a 6-element tuple.
func Func<Error, ValueTask>: The async side effect function to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(Result<(T1, T2, T3, T4, T5, T6)>, Func<Task>)

Executes an asynchronous side effect action when a synchronous 6-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(this Result<(T1, T2, T3, T4, T5, T6)> result, Func<Task> func)

Parameters

result Result<(T1, T2, T3, T4, T5, T6)>: The result containing a 6-element tuple.
func Func<Task>: The async side effect function to execute on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(Result<(T1, T2, T3, T4, T5, T6)>, Func<ValueTask>)

Executes an asynchronous side effect action when a synchronous 6-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(this Result<(T1, T2, T3, T4, T5, T6)> result, Func<ValueTask> func)

Parameters

result Result<(T1, T2, T3, T4, T5, T6)>: The result containing a 6-element tuple.
func Func<ValueTask>: The async side effect function to execute on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(Result<(T1, T2, T3, T4, T5, T6)>, Func<Error, Task>)

Executes an asynchronous side effect action with the error when a synchronous 6-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(this Result<(T1, T2, T3, T4, T5, T6)> result, Func<Error, Task> func)

Parameters

result Result<(T1, T2, T3, T4, T5, T6)>: The result containing a 6-element tuple.
func Func<Error, Task>: The async side effect function to execute with the error on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(Result<(T1, T2, T3, T4, T5, T6)>, Func<Error, ValueTask>)

Executes an asynchronous side effect action with the error when a synchronous 6-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6>(this Result<(T1, T2, T3, T4, T5, T6)> result, Func<Error, ValueTask> func)

Parameters

result Result<(T1, T2, T3, T4, T5, T6)>: The result containing a 6-element tuple.
func Func<Error, ValueTask>: The async side effect function to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(Task<Result<(T1, T2, T3, T4, T5, T6, T7)>>, Action)

Executes a synchronous side effect action when an asynchronous 7-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6, T7)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(this Task<Result<(T1, T2, T3, T4, T5, T6, T7)>> resultTask, Action action)

Parameters

resultTask Task<Result<(T1, T2, T3, T4, T5, T6, T7)>>: The task representing the result containing a 7-element tuple.
action Action: The side effect action to execute on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6, T7)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(Task<Result<(T1, T2, T3, T4, T5, T6, T7)>>, Action<Error>)

Executes a synchronous side effect action with the error when an asynchronous 7-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6, T7)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(this Task<Result<(T1, T2, T3, T4, T5, T6, T7)>> resultTask, Action<Error> action)

Parameters

resultTask Task<Result<(T1, T2, T3, T4, T5, T6, T7)>>: The task representing the result containing a 7-element tuple.
action Action<Error>: The side effect action to execute with the error on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6, T7)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(Task<Result<(T1, T2, T3, T4, T5, T6, T7)>>, Func<Task>)

Executes an asynchronous side effect action when an asynchronous 7-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6, T7)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(this Task<Result<(T1, T2, T3, T4, T5, T6, T7)>> resultTask, Func<Task> func)

Parameters

resultTask Task<Result<(T1, T2, T3, T4, T5, T6, T7)>>: The task representing the result containing a 7-element tuple.
func Func<Task>: The async side effect function to execute on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6, T7)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(Task<Result<(T1, T2, T3, T4, T5, T6, T7)>>, Func<Error, Task>)

Executes an asynchronous side effect action with the error when an asynchronous 7-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6, T7)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(this Task<Result<(T1, T2, T3, T4, T5, T6, T7)>> resultTask, Func<Error, Task> func)

Parameters

resultTask Task<Result<(T1, T2, T3, T4, T5, T6, T7)>>: The task representing the result containing a 7-element tuple.
func Func<Error, Task>: The async side effect function to execute with the error on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6, T7)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>>, Action)

Executes a synchronous side effect action when an asynchronous 7-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(this ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>> resultTask, Action action)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>>: The ValueTask representing the result containing a 7-element tuple.
action Action: The side effect action to execute on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>>, Action<Error>)

Executes a synchronous side effect action with the error when an asynchronous 7-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(this ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>> resultTask, Action<Error> action)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>>: The ValueTask representing the result containing a 7-element tuple.
action Action<Error>: The side effect action to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>>, Func<ValueTask>)

Executes an asynchronous side effect action when an asynchronous 7-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(this ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>> resultTask, Func<ValueTask> func)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>>: The ValueTask representing the result containing a 7-element tuple.
func Func<ValueTask>: The async side effect function to execute on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>>, Func<Error, ValueTask>)

Executes an asynchronous side effect action with the error when an asynchronous 7-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(this ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>> resultTask, Func<Error, ValueTask> func)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>>: The ValueTask representing the result containing a 7-element tuple.
func Func<Error, ValueTask>: The async side effect function to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(Result<(T1, T2, T3, T4, T5, T6, T7)>, Func<Task>)

Executes an asynchronous side effect action when a synchronous 7-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6, T7)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(this Result<(T1, T2, T3, T4, T5, T6, T7)> result, Func<Task> func)

Parameters

result Result<(T1, T2, T3, T4, T5, T6, T7)>: The result containing a 7-element tuple.
func Func<Task>: The async side effect function to execute on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6, T7)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(Result<(T1, T2, T3, T4, T5, T6, T7)>, Func<ValueTask>)

Executes an asynchronous side effect action when a synchronous 7-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(this Result<(T1, T2, T3, T4, T5, T6, T7)> result, Func<ValueTask> func)

Parameters

result Result<(T1, T2, T3, T4, T5, T6, T7)>: The result containing a 7-element tuple.
func Func<ValueTask>: The async side effect function to execute on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(Result<(T1, T2, T3, T4, T5, T6, T7)>, Func<Error, Task>)

Executes an asynchronous side effect action with the error when a synchronous 7-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6, T7)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(this Result<(T1, T2, T3, T4, T5, T6, T7)> result, Func<Error, Task> func)

Parameters

result Result<(T1, T2, T3, T4, T5, T6, T7)>: The result containing a 7-element tuple.
func Func<Error, Task>: The async side effect function to execute with the error on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6, T7)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(Result<(T1, T2, T3, T4, T5, T6, T7)>, Func<Error, ValueTask>)

Executes an asynchronous side effect action with the error when a synchronous 7-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7>(this Result<(T1, T2, T3, T4, T5, T6, T7)> result, Func<Error, ValueTask> func)

Parameters

result Result<(T1, T2, T3, T4, T5, T6, T7)>: The result containing a 7-element tuple.
func Func<Error, ValueTask>: The async side effect function to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>, Action)

Executes a synchronous side effect action when an asynchronous 8-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(this Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>> resultTask, Action action)

Parameters

resultTask Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>: The task representing the result containing a 8-element tuple.
action Action: The side effect action to execute on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>, Action<Error>)

Executes a synchronous side effect action with the error when an asynchronous 8-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(this Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>> resultTask, Action<Error> action)

Parameters

resultTask Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>: The task representing the result containing a 8-element tuple.
action Action<Error>: The side effect action to execute with the error on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>, Func<Task>)

Executes an asynchronous side effect action when an asynchronous 8-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(this Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>> resultTask, Func<Task> func)

Parameters

resultTask Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>: The task representing the result containing a 8-element tuple.
func Func<Task>: The async side effect function to execute on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>, Func<Error, Task>)

Executes an asynchronous side effect action with the error when an asynchronous 8-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(this Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>> resultTask, Func<Error, Task> func)

Parameters

resultTask Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>: The task representing the result containing a 8-element tuple.
func Func<Error, Task>: The async side effect function to execute with the error on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>, Action)

Executes a synchronous side effect action when an asynchronous 8-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(this ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>> resultTask, Action action)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>: The ValueTask representing the result containing a 8-element tuple.
action Action: The side effect action to execute on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>, Action<Error>)

Executes a synchronous side effect action with the error when an asynchronous 8-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(this ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>> resultTask, Action<Error> action)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>: The ValueTask representing the result containing a 8-element tuple.
action Action<Error>: The side effect action to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>, Func<ValueTask>)

Executes an asynchronous side effect action when an asynchronous 8-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(this ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>> resultTask, Func<ValueTask> func)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>: The ValueTask representing the result containing a 8-element tuple.
func Func<ValueTask>: The async side effect function to execute on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>, Func<Error, ValueTask>)

Executes an asynchronous side effect action with the error when an asynchronous 8-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(this ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>> resultTask, Func<Error, ValueTask> func)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>: The ValueTask representing the result containing a 8-element tuple.
func Func<Error, ValueTask>: The async side effect function to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(Result<(T1, T2, T3, T4, T5, T6, T7, T8)>, Func<Task>)

Executes an asynchronous side effect action when a synchronous 8-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(this Result<(T1, T2, T3, T4, T5, T6, T7, T8)> result, Func<Task> func)

Parameters

result Result<(T1, T2, T3, T4, T5, T6, T7, T8)>: The result containing a 8-element tuple.
func Func<Task>: The async side effect function to execute on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(Result<(T1, T2, T3, T4, T5, T6, T7, T8)>, Func<ValueTask>)

Executes an asynchronous side effect action when a synchronous 8-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(this Result<(T1, T2, T3, T4, T5, T6, T7, T8)> result, Func<ValueTask> func)

Parameters

result Result<(T1, T2, T3, T4, T5, T6, T7, T8)>: The result containing a 8-element tuple.
func Func<ValueTask>: The async side effect function to execute on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(Result<(T1, T2, T3, T4, T5, T6, T7, T8)>, Func<Error, Task>)

Executes an asynchronous side effect action with the error when a synchronous 8-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(this Result<(T1, T2, T3, T4, T5, T6, T7, T8)> result, Func<Error, Task> func)

Parameters

result Result<(T1, T2, T3, T4, T5, T6, T7, T8)>: The result containing a 8-element tuple.
func Func<Error, Task>: The async side effect function to execute with the error on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(Result<(T1, T2, T3, T4, T5, T6, T7, T8)>, Func<Error, ValueTask>)

Executes an asynchronous side effect action with the error when a synchronous 8-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8>(this Result<(T1, T2, T3, T4, T5, T6, T7, T8)> result, Func<Error, ValueTask> func)

Parameters

result Result<(T1, T2, T3, T4, T5, T6, T7, T8)>: The result containing a 8-element tuple.
func Func<Error, ValueTask>: The async side effect function to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>, Action)

Executes a synchronous side effect action when an asynchronous 9-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>> resultTask, Action action)

Parameters

resultTask Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>: The task representing the result containing a 9-element tuple.
action Action: The side effect action to execute on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.
T9: The type of element 9 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>, Action<Error>)

Executes a synchronous side effect action with the error when an asynchronous 9-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>> resultTask, Action<Error> action)

Parameters

resultTask Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>: The task representing the result containing a 9-element tuple.
action Action<Error>: The side effect action to execute with the error on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.
T9: The type of element 9 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>, Func<Task>)

Executes an asynchronous side effect action when an asynchronous 9-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>> resultTask, Func<Task> func)

Parameters

resultTask Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>: The task representing the result containing a 9-element tuple.
func Func<Task>: The async side effect function to execute on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.
T9: The type of element 9 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>, Func<Error, Task>)

Executes an asynchronous side effect action with the error when an asynchronous 9-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>> resultTask, Func<Error, Task> func)

Parameters

resultTask Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>: The task representing the result containing a 9-element tuple.
func Func<Error, Task>: The async side effect function to execute with the error on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.
T9: The type of element 9 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>, Action)

Executes a synchronous side effect action when an asynchronous 9-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>> resultTask, Action action)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>: The ValueTask representing the result containing a 9-element tuple.
action Action: The side effect action to execute on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.
T9: The type of element 9 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>, Action<Error>)

Executes a synchronous side effect action with the error when an asynchronous 9-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>> resultTask, Action<Error> action)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>: The ValueTask representing the result containing a 9-element tuple.
action Action<Error>: The side effect action to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.
T9: The type of element 9 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>, Func<ValueTask>)

Executes an asynchronous side effect action when an asynchronous 9-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>> resultTask, Func<ValueTask> func)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>: The ValueTask representing the result containing a 9-element tuple.
func Func<ValueTask>: The async side effect function to execute on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.
T9: The type of element 9 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>, Func<Error, ValueTask>)

Executes an asynchronous side effect action with the error when an asynchronous 9-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>> resultTask, Func<Error, ValueTask> func)

Parameters

resultTask ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>: The ValueTask representing the result containing a 9-element tuple.
func Func<Error, ValueTask>: The async side effect function to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.
T9: The type of element 9 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>, Func<Task>)

Executes an asynchronous side effect action when a synchronous 9-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)> result, Func<Task> func)

Parameters

result Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>: The result containing a 9-element tuple.
func Func<Task>: The async side effect function to execute on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.
T9: The type of element 9 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>, Func<ValueTask>)

Executes an asynchronous side effect action when a synchronous 9-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)> result, Func<ValueTask> func)

Parameters

result Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>: The result containing a 9-element tuple.
func Func<ValueTask>: The async side effect function to execute on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.
T9: The type of element 9 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>, Func<Error, Task>)

Executes an asynchronous side effect action with the error when a synchronous 9-element tuple result fails.

public static Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)> result, Func<Error, Task> func)

Parameters

result Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>: The result containing a 9-element tuple.
func Func<Error, Task>: The async side effect function to execute with the error on failure.

Returns

Task<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>: A task that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.
T9: The type of element 9 in the tuple.

TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>, Func<Error, ValueTask>)

Executes an asynchronous side effect action with the error when a synchronous 9-element tuple result fails (ValueTask variant).

public static ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>> TapOnFailureAsync<T1, T2, T3, T4, T5, T6, T7, T8, T9>(this Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)> result, Func<Error, ValueTask> func)

Parameters

result Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>: The result containing a 9-element tuple.
func Func<Error, ValueTask>: The async side effect function to execute with the error on failure.

Returns

ValueTask<Result<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>>: A ValueTask that represents the asynchronous operation containing the original result unchanged.

Type Parameters

T1: The type of element 1 in the tuple.
T2: The type of element 2 in the tuple.
T3: The type of element 3 in the tuple.
T4: The type of element 4 in the tuple.
T5: The type of element 5 in the tuple.
T6: The type of element 6 in the tuple.
T7: The type of element 7 in the tuple.
T8: The type of element 8 in the tuple.
T9: The type of element 9 in the tuple.

Table of Contents

Class TapOnFailureExtensionsAsync

Examples

Remarks

Methods

TapOnFailureAsync<TValue>(Task<Result<TValue>>, Action)

Parameters

Returns

Type Parameters

TapOnFailureAsync<TValue>(Task<Result<TValue>>, Action<Error>)

Parameters

Returns

Type Parameters

TapOnFailureAsync<TValue>(Task<Result<TValue>>, Func<Task>)

Parameters

Returns

Type Parameters

TapOnFailureAsync<TValue>(Task<Result<TValue>>, Func<Error, Task>)

Parameters

Returns

Type Parameters

TapOnFailureAsync<TValue>(ValueTask<Result<TValue>>, Action)

Parameters

Returns

Type Parameters

TapOnFailureAsync<TValue>(ValueTask<Result<TValue>>, Action<Error>)

Parameters

Returns

Type Parameters

TapOnFailureAsync<TValue>(ValueTask<Result<TValue>>, Func<ValueTask>)

Parameters

Returns

Type Parameters

TapOnFailureAsync<TValue>(ValueTask<Result<TValue>>, Func<Error, ValueTask>)

Parameters

Returns

Type Parameters

TapOnFailureAsync<TValue>(Result<TValue>, Func<Task>)

Parameters

Returns

Type Parameters

Remarks

TapOnFailureAsync<TValue>(Result<TValue>, Func<ValueTask>)

Parameters

Returns

Type Parameters

TapOnFailureAsync<TValue>(Result<TValue>, Func<Error, Task>)

Parameters

Returns

Type Parameters

Remarks

TapOnFailureAsync<TValue>(Result<TValue>, Func<Error, ValueTask>)

Parameters

Returns

Type Parameters

TapOnFailureAsync<T1, T2>(Task<Result<(T1, T2)>>, Action)

Parameters

Returns

Type Parameters

TapOnFailureAsync<T1, T2>(Task<Result<(T1, T2)>>, Action<Error>)

Parameters

Returns

Type Parameters

TapOnFailureAsync<T1, T2>(Task<Result<(T1, T2)>>, Func<Task>)

Parameters

Returns

Type Parameters

TapOnFailureAsync<T1, T2>(Task<Result<(T1, T2)>>, Func<Error, Task>)

Parameters

Returns

Type Parameters

TapOnFailureAsync<T1, T2>(ValueTask<Result<(T1, T2)>>, Action)

Parameters

Returns

Type Parameters

TapOnFailureAsync<T1, T2>(ValueTask<Result<(T1, T2)>>, Action<Error>)

Parameters

Returns

Type Parameters

TapOnFailureAsync<T1, T2>(ValueTask<Result<(T1, T2)>>, Func<ValueTask>)