Updated result and added ErrorCodes

Author: dtymakhov

ManagedCode.Communication/BaseResult.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace ManagedCode.Communication;
+
+public abstract class BaseResult<TErrorCode> where TErrorCode : Enum
+{
+    public bool IsSuccess { get; }
+    public bool IsFail => !IsSuccess;
+    public Error<TErrorCode>? Error => Errors?.FirstOrDefault();
+    public List<Error<TErrorCode>>? Errors { get; set; }
+
+
+    protected BaseResult(bool isSuccess)
+    {
+        IsSuccess = isSuccess;
+    }
+
+    protected BaseResult(Error<TErrorCode> error)
+    {
+        IsSuccess = false;
+        Errors = new List<Error<TErrorCode>> {error};
+    }
+
+    protected BaseResult(List<Error<TErrorCode>> errors)
+    {
+        IsSuccess = false;
+        Errors = errors;
+    }
+}
+
+public abstract class BaseResult<T, TErrorCode> : BaseResult<TErrorCode> where TErrorCode : Enum
+{
+    public T? Value { get; }
+    public T? ValueOrDefault(T? defaultValue = default) => Value ?? defaultValue;
+
+    protected BaseResult(T value) : base(true)
+    {
+        Value = value;
+    }
+
+    protected BaseResult(bool isSuccess) : base(isSuccess)
+    {
+    }
+
+    protected BaseResult(Error<TErrorCode> error) : base(error)
+    {
+    }
+
+    protected BaseResult(List<Error<TErrorCode>> errors) : base(errors)
+    {
+    }
+}

ManagedCode.Communication/Error.cs

@@ -2,19 +2,35 @@
 
 namespace ManagedCode.Communication;
 
-public class Error
+public class Error<TErrorCode> where TErrorCode : Enum
 {
-    public Error(string message)
+    public Error(string message, TErrorCode? errorCode = default)
     {
         Message = message;
+        ErrorCode = errorCode;
     }
 
-    public Error(Exception? exception)
+    public Error(Exception exception, TErrorCode? errorCode = default)
     {
         Exception = exception;
-        Message = exception.Message;
+        ErrorCode = errorCode;
+        Message = exception.Message ?? string.Empty;
     }
 
-    public Exception? Exception { get; set; }
+    public Error(Exception exception, string message, TErrorCode? errorCode = default)
+    {
+        Exception = exception;
+        ErrorCode = errorCode;
+        Message = message;
+    }
+
+
     public string Message { get; set; }
+    public Exception? Exception { get; set; }
+    public TErrorCode? ErrorCode { get; set; }
+
+    public static Error<TErrorCode> FromException(Exception exception, TErrorCode? errorCode = default)
+    {
+        return new Error<TErrorCode>(exception, errorCode);
+    }
 }

ManagedCode.Communication/ErrorCode.cs

@@ -0,0 +1,16 @@
+namespace ManagedCode.Communication;
+
+public enum ErrorCode
+{
+    Unknown,
+    InvalidArguments,
+    InvalidOperation,
+    InvalidState,
+    NotFound,
+    NotSupported,
+    Timeout,
+    AccessDenied,
+    NotImplemented,
+    NotInitialized,
+    AlreadyExists,
+}

ManagedCode.Communication/Result.cs

@@ -1,84 +1,71 @@
 using System;
+using System.Collections.Generic;
 
 namespace ManagedCode.Communication;
 
-public class Result
+public class Result : BaseResult<ErrorCode>
 {
-    public bool IsSuccess { get; }
-    public bool IsError => !IsSuccess;
-    public Error? Error { get; }
-
-    protected Result(Exception exception)
+    internal Result(bool isSuccess) : base(isSuccess)
     {
-        IsSuccess = false;
-        Error = new Error(exception);
     }
 
-    protected Result(string errorMessage)
+    internal Result(Error<ErrorCode> error) : base(error)
     {
-        IsSuccess = false;
-        Error = new Error(errorMessage);
     }
 
-    protected Result(bool isSuccess)
+    internal Result(List<Error<ErrorCode>> errors) : base(errors)
     {
-        IsSuccess = isSuccess;
-        Error = null;
     }
 
-    protected Result(Error error)
-    {
-        IsSuccess = false;
-        Error = error;
-    }
 
-    public static Result Succeed()
-    {
-        return new Result(true);
-    }
+    public static implicit operator Result(Error<ErrorCode> error) => new(error);
+    public static implicit operator Result(List<Error<ErrorCode>> errors) => new(errors);
 
-    public static Result Fail()
-    {
-        return new Result(false);
-    }
 
-    public static Result Fail(Error error)
-    {
-        return new Result(error);
-    }
+    public static Result Success() => new(true);
+    public static Result Fail() => new(false);
+    public static Result Fail(Error<ErrorCode> error) => new(error);
+    public static Result Fail(List<Error<ErrorCode>> errors) => new(errors);
+}
 
-    public static Result Fail(Exception error)
+public class Result<T> : BaseResult<T, ErrorCode>
+{
+    internal Result(T value) : base(value)
     {
-        return new Result(error);
     }
 
-    public static Result Fail(string errorMessage)
+    internal Result(bool isSuccess) : base(isSuccess)
     {
-        return new Result(errorMessage);
     }
 
-    public static Result<T> Succeed<T>(T content)
+    internal Result(Error<ErrorCode> error) : base(error)
     {
-        return new Result<T>(true, content);
     }
 
-    public static Result<T> Fail<T>()
+    internal Result(List<Error<ErrorCode>> errors) : base(errors)
     {
-        return new Result<T>(false);
     }
 
-    public static Result<T> Fail<T>(Error error)
-    {
-        return new Result<T>(error);
-    }
 
-    public static Result<T> Fail<T>(Exception exception)
-    {
-        return new Result<T>(exception);
-    }
+    public static implicit operator Result<T>(T value) => new(value);
+    public static implicit operator Result<T>(Error<ErrorCode> error) => new(error);
+    public static implicit operator Result<T>(List<Error<ErrorCode>> errors) => new(errors);
+
 
-    public static Result<T> Fail<T>(string errorMessage)
+    public static Result<T> Success(T value) => new(value);
+    public static Result<T> Fail() => new(false);
+    public static Result<T> Fail(Error<ErrorCode> error) => new(error);
+    public static Result<T> Fail(List<Error<ErrorCode>> errors) => new(errors);
+
+    
+    public Result<T> WithError(Error<ErrorCode> error)
     {
-        return new Result<T>(errorMessage);
+        if (IsSuccess)
+        {
+            throw new InvalidOperationException("Cannot add error to success result");
+        }
+
+        Errors!.Add(error);
+        return this;
     }
 }

ManagedCode.Communication/ResultExtensions.cs

@@ -1,20 +1,16 @@
+using System;
 using System.Threading.Tasks;
 
 namespace ManagedCode.Communication;
 
 public static class ResultExtensions
 {
-    public static Result<T> ToSucceededResult<T>(this T value)
-    {
-        return new Result<T>(true, value);
-    }
-
-    public static Task<Result<T>> AsTask<T>(this Result<T> value)
+    public static Task<BaseResult<T, TErrorCode>> AsTask<T, TErrorCode>(this BaseResult<T, TErrorCode> value) where TErrorCode : Enum
     {
         return Task.FromResult(value);
     }
 
-    public static Task<Result> AsTask(this Result value)
+    public static Task<BaseResult<TErrorCode>> AsTask<TErrorCode>(this BaseResult<TErrorCode> value) where TErrorCode : Enum
     {
         return Task.FromResult(value);
     }