Bdtjtk

Recently I have started building new application, this is a .Net Core based MVC and Webapi application.

One of my senior came-up with Idea of WrappedResult as return type of each and every method. so that we need not to throw exception. Following is the structure of

public class WrappedResult<T>

{

    public T Result { get; set; }

    public bool IsSuccess

    {

        get

        {

            return !string.IsNullOrWhiteSpace(SuccessMessage);

        }

    }

    public string SuccessMessage { get; set; }

    public bool HasError

    {

        get

        {

            return Errors.Count > 0;

        }

    }



    public List<RectoError> Errors { get; set; } = new List<RectoError>();



    public void AddError(ErrorCode errorCode = ErrorCode.None, string errorMessage = null)

    {

        var rectoError = new RectoError()

        {

            ErrorCode = errorCode,

            ErrorMessage = errorMessage,                

        };

        Errors.Add(rectoError);

    }



    public void AddError(RectoError rectoError)

    {

        Errors.Add(rectoError);

    }



    public Task<WrappedResult<T>> ToTask()

    {

        return Task.Factory.StartNew(() => {

            return this;

        });

    }

}



public class RectoError

{        

    public ErrorCode ErrorCode { get; set; }

    public Exception Exception { get; set; }

    public string ErrorMessage { get; set; }

}

And he suggest to use this object as return type of each and every method of all the classes where we are expected to use try/catch in every method and also where ever these methods are called those are expected to check the response of previous method

Check sample below,

    public async Task<WrappedResult<List<AreaUserStagingDto>>> GetAreaUsersInStaging(UserDto currentUser)

    {

        WrappedResult<List<AreaUserStagingDto>> result = new WrappedResult<List<AreaUserStagingDto>>();

        try

        {

            var query = null; //<= get output from database



            result.Result = query;

        }

        catch (Exception ex)

        {

            _dbManager.HandleDbException(ex, ref result, currentUser);

        }



        return result;

    }

I have following concerns with this way of exception handling.

• Uselessly we will be using try/catch block through out the code base,
  whereas we should only handle exception in entry point or where we
  need to do something else on exception.


• It will need extra lines of code for each method. Program need to check for
  errors every time even if there is no exception 99.9 percentage of time.

I think there could be more drawback of following this approach,

Does anyone see any benefit of this way of handling exception and returning WrappedResult.