public static IRollbackActionResult <TOut> Bind <TIn, TOut>(
this IRollbackAction <TIn, TOut> action, IRollbackActionResult <TIn> parameter)
{
action.ThrowIfNull(nameof(action));
parameter.ThrowIfNull(nameof(parameter));
switch (parameter)
{
case FailedResult failedResult:
{
throw failedResult.Exception.Rethrow();
}
case SuccessfulResult <TIn> successfulResult:
{
try
{
TOut result = action.Execute(successfulResult.Result);
return(new SuccessfulResult <TOut>(
result, successfulResult.RollbackList.Prepend(action)
));
}
catch (Exception)
{
successfulResult.RollbackList.TryRollbackSafe();
throw;
}
}
default:
{
throw new ArgumentException("Invalid parameter.", nameof(parameter));
}
}
}
public static IRollbackActionResult <TOut> Bind <TIn, TOut>(
this IRollbackAction <TIn, TOut> action, TIn parameter)
{
return(Bind(
action, new SuccessfulResult <TIn>(parameter, Enumerable.Empty <IRollbackAction>())
));
}
public void Add(IRollbackAction rollbackAction)
{
rollbackAction.ThrowIfNull(nameof(rollbackAction));
EnsureScopeIsNotDisposed(_disposed);
_rollbackActions.Push(rollbackAction);
}
public void Add(IRollbackAction rollbackAction)
{
rollbackAction.ThrowIfNull(nameof(rollbackAction));
if (_disposed)
{
throw new ObjectDisposedException(nameof(RollbackScope), "Failed to add action to disposed scope.");
}
_rollbackActions.Push(rollbackAction);
}
private bool TryRollbackInternalSafe(bool disposing)
{
if (_disposed)
{
Logger.Warning(
"Tried to rollback actions for disposed scope. Rollback will not be perform."
);
return(false);
}
if (_rollbackActions.Count == 0)
{
Logger.Debug("No rollback actions to perform.");
return(true);
}
string message =
$"Performing {_rollbackActions.Count.ToString()} rollback actions. " +
$"Continue rollback on failed: '{_continueRollbackOnFailed.ToString()}'.";
if (disposing)
{
Logger.Warning(message);
}
else
{
Logger.Debug(message);
}
bool isSuccessfulRollback = true;
while (ShouldContinueRollback(isSuccessfulRollback))
{
IRollbackAction rollbackAction = _rollbackActions.Pop();
isSuccessfulRollback = InternalRollbackSafe(rollbackAction);
}
Logger.Debug(
$"Scope remains {_rollbackActions.Count.ToString()} non-completed rollback " +
"action. Some actions may failed."
);
_rollbackActions.TrimExcess();
return(isSuccessfulRollback);
}
public bool TryRollbackSafe()
{
if (_disposed)
{
Logger.Warning("Tried to rollback actions for disposed scope. Rollback will not be perform.");
return(false);
}
Logger.Warning($"Performing {_rollbackActions.Count.ToString()} rollback actions.");
bool isSuccessfulRollback = true;
while (_rollbackActions.Count > 0 && isSuccessfulRollback)
{
IRollbackAction rollbackAction = _rollbackActions.Pop();
isSuccessfulRollback = rollbackAction.TryRollbackSafe();
}
_rollbackActions.TrimExcess();
return(isSuccessfulRollback);
}
private bool InternalRollbackSafe(IRollbackAction rollbackAction)
{
try
{
Logger.Debug(
"Trying to rollback action. If exception will occur, this will be considered " +
"as a failed rollback."
);
return(rollbackAction.TryRollbackSafe());
}
catch (Exception ex)
{
string lastPartOfMessage = _continueRollbackOnFailed
? "Continue rollback on failed option is enabled, the rollback will continue."
: "Continue rollback on failed option is disabled, the rest of rollback " +
"actions will be skipped.";
Logger.Exception(
ex, $"Failed to perform safe rollback for action. {lastPartOfMessage}"
);
return(false);
}
}
public static IRollbackActionResult <TOut> Bind <TIn, TOut>(
this IRollbackActionResult <TIn> parameter, IRollbackAction <TIn, TOut> action)
{
return(Bind(action, parameter));
}
