using System;

using System.Collections.Generic;

using System.Linq;

public class Program

{

    static Repo r = new Repo();

    public static void Main()

    {

        LogResult(new Foo { Name = "Yay!" });

        LogResult(new Foo { Name = "Fail" });

    }

    private static void LogResult(Foo foo) {

        var result = r.Add(foo);

        if (result.Succeeded)

            Console.WriteLine($"Success New Id: {result.Value.Id}");

        else {

            var errors = string.Join(", ", result.Errors.Select(x => x.Description));

            Console.WriteLine($"Fail: {errors}");

        }

    }

}

​

public class Repo : IRepo {

    private List<Foo> foos = new List<Foo>();

    private int count = 0;

    public IOperationResult<Foo> Add(Foo foo) {

        if (foo.Name == "Fail") {

            return OperationResult.Failed<Foo>("Some business rule failed");

        }

        count++;

        foo.Id = count;

        foos.Add(foo);

        return OperationResult.SucceededWithValue<Foo>(foo);

    }

}

​

public interface IRepo {

    public IOperationResult<Foo> Add(Foo foo);

}

​

public interface IOperationResult

{

    public bool Succeeded { get; }

​

    public IEnumerable<OperationError> Errors { get; }

}

​

public interface IOperationResult<out T>: IOperationResult

{

    public T Value { get; }

}

​

public class OperationResult: IOperationResult

    {

        public bool Succeeded { get; init; }

​

        public IEnumerable<OperationError> Errors { get; init; } = new List<OperationError>();

​

        public static OperationResult Success { get; } = new() { Succeeded = true };

        public static OperationResult<T> SucceededWithValue<T>(T value)

        {

            return new()

            {

                Succeeded = true,

                Value = value

            };

        }

​

        public static OperationResult Failed(params OperationError[] errors)

        {

            var result = new OperationResult

            {

                Succeeded = false,

                Errors = errors ?? Array.Empty<OperationError>()

            };

            return result;

        }

​

        public static OperationResult Failed(IEnumerable<OperationError> errors)

        {

            var result = new OperationResult

            {

                Succeeded = false,

                Errors = errors ?? Array.Empty<OperationError>()

            };

            return result;

        }

​

        public static OperationResult<T> Failed<T>(params OperationError[] errors)

        {

            var result = new OperationResult<T>

            {

                Succeeded = false,

                Errors = errors ?? Array.Empty<OperationError>()

            };

            return result;

        }

​

        public static OperationResult<T> Failed<T>(IEnumerable<OperationError> errors)

        {

            var result = new OperationResult<T>

            {

                Succeeded = false,

                Errors = errors ?? Array.Empty<OperationError>()

            };

            return result;

        }

    }

​

    public class OperationResult<T> : OperationResult, IOperationResult<T>

    {

        public T Value { get; init; }

    }

​

    public class OperationError

    {

        public OperationError(string description)

        {

            Description = description;

        }

​

        /// <summary>

        /// Gets or sets the description for this error.

        /// </summary>

        /// <value>

        /// The description for this error.

        /// </value>

        public string Description { get; set; }

​

        public static implicit operator OperationError(string description)

        {

            return new(description);

        }

    }

​

public class Foo {

    public int Id {get;set;}

    public string Name {get;set;}

}