Implicit operator from Result<T> to Result<U>

[PatrizioG]

Hi
I would be interested in having an implicit operator from Result<T> to Result<U> just to maintain the state of internal properties.
I have a method that can return a Result<int> on success:

 protected virtual async Task<Result<int>> SaveChangesReturnResultAsync()
 {
     try
     {
         var numberOfWritings = await Context.SaveChangesAsync();
         return Result.Success(numberOfWritings);
     }
     catch (Exception ex)
     {
         if (ex.IsEntityAlreadyExistsException())
             return Result.Conflict("Entity Already Exists");

         if (ex.IsForeignKeyViolation())
             return Result.Conflict("Foreign Key Violation");

         throw;
     }
 }

But the caller must be able to return a Result<Tentity> if successful or propogate errors from the previous call:

  public virtual async Task<Result<TEntity>> CreateAndReturnResultAsync(TEntity entity)
  {
      await Context.AddAsync(entity);
      var result = await SaveChangesReturnResultAsync();
      if (!result.IsSuccess)
          return result; // Conversion error
      return Result.Success(entity);
  }

Currently what I have been able to obtain from the code base is a new implicit operator:

public static implicit operator Result(Result<T> result) => new()
{
    Status = result.Status,
    Errors = result.Errors,
    SuccessMessage = result.SuccessMessage,
    CorrelationId = result.CorrelationId,
    ValidationErrors = result.ValidationErrors,
};

But this fix would force you to perform two conversion steps:

    public virtual async Task<Result<TEntity>> CreateAndReturnResultAsync(TEntity entity)
    {
        await Context.AddAsync(entity);
        var result = await SaveChangesReturnResultAsync();
        Result temp = result; // From Result<int> to Result, to me it's ok to lost the original value.
        if (!result.IsSuccess)
            return temp; // Conversion ok
        return Result.Success(entity);
    }

Thanks in advance

[jmrtnz94]

Would the Map extensions method fit your use case?

https://github.com/ardalis/Result/blob/main/src/Ardalis.Result/ResultExtensions.cs#L17

[KyleMcMaster]

I agree with @jmrtnz94 that the appropriate solution would be to use Map to convert between types.

[PatrizioG]

Thank you very much, now I understand how to use the map method to handle my specific case. I close the issue.

[PatrizioG]

But with this approach it seems to me that I can't map from Result<T> to Result keeping internal errors and status.
Any suggestion?

[KyleMcMaster]

But with this approach it seems to me that I can't map from Result<T> to Result keeping internal errors and status. Any suggestion?

This is fixed in #213, we're working on getting that PR merged soon and a release out shortly.

[KyleMcMaster]

@PatrizioG I believe this issue can be marked as closed as release 10.1.0 includes an overload of Map that allows converting from Result<T> to Result.

Example usage here:

Result/tests/Ardalis.Result.UnitTests/ResultGenericToVoidMap.cs

Lines 71 to 84 in d38ccbd

	[Fact]
	public void ShouldProduceErrorWhenConstructedWithErrorList()
	{
	string correlationId = Guid.NewGuid().ToString();
	string errorMessage = "Error occured 💥";
	var result = Result<int>.Error(new ErrorList([errorMessage], correlationId));
	var actual = result.Map();
	using var assertionScope = new AssertionScope();
	actual.Status.Should().Be(ResultStatus.Error);
	actual.CorrelationId.Should().Be(correlationId);
	actual.Errors.Single().Should().Be(errorMessage);
	}

[PatrizioG]

Ok @KyleMcMaster thanks so much!