Result

gistfile1.txt

    public interface IResult
    {
        bool WasSuccessful { get; }
        string[] Errors { get; }
        bool WasFailure { get; }
    }

    public class Result : IResult
    {
        private string[] _errors;

        private Result()
        {

        }

        public bool WasSuccessful { get; private set; }
        public bool WasFailure
        {
            get { return !WasSuccessful; }
        }

        public string[] Errors
        {
            get { return _errors.ToArray(); }
        }

        public string ErrorString
        {
            get { return string.Join(Environment.NewLine, _errors); }
        }


        public static Result Failed(params string[] errors)
        {
            return new Result() { _errors = errors.ToArray() };
        }

        public static Result Failed(params IResult[] becauseOf)
        {
            return new Result() { _errors = becauseOf.SelectMany(b => b.Errors).ToArray() };
        }

        public static Result Success()
        {
            return new Result() { WasSuccessful = true};
        }

        public static Result From(params Result[] results)
        {
            var failed = results.Where(r => !r.WasSuccessful).ToArray();
            if (failed.Length == 0)
                return Result.Success();
            return Result.Failed(failed.SelectMany(f => f.Errors).ToArray());
        }
    }

    public class Result<T> : IResult
    {
        private T _value;
        private string[] _errors;

        private Result()
        {

        }

        public bool WasSuccessful { get; private set; }

        public string[] Errors
        {
            get {
                return _errors!= null ? _errors.ToArray() : null;
            }
        }

        public string ErrorString
        {
            get
            {
                return _errors != null ? string.Join(Environment.NewLine, _errors) : null;
            }
        }

        public T Value
        {
            get
            {
                if (!WasSuccessful)
                    throw new Exception("No value as the operation was not successful");
                return _value;
            }
        }

        public bool WasFailure
        {
            get { return !WasSuccessful; }
        }

        public static Result<T> Failed()
        {
            return new Result<T>() {_errors = new string[0]};
        }

        public static Result<T> Failed(params string[] errors)
        {
            return new Result<T>() {_errors = errors.ToArray()};
        }

        public static Result<T> Failed(params IResult[] becauseOf)
        {
            return new Result<T>() {_errors = becauseOf.SelectMany(b => b.Errors).ToArray()};
        }

        public static Result<T> Success(T value)
        {
            return new Result<T>() {WasSuccessful = true, _value = value};
        }

        public static implicit operator Result<T>(T value)
        {
            return Success(value);
        }

        public static implicit operator T(Result<T> result)
        {
            return result.Value;
        }

        public T ValueOr(T def)
        {
            return WasSuccessful ? Value : def;
        }

        public override string ToString()
        {
            return WasSuccessful
                ? "" + Value
                : ErrorString;
        }

        public static Result<T> From<TIn>(Result<TIn> result) where TIn : T
        {
            return result.WasSuccessful
                ? Success(result.Value)
                : Failed(result);
        }
    }