ChainOfResponsability.cs

using System;
using System.Linq;

namespace ChainOfResponsability {
    //pseudo classes
    public class Eficacia
    {
        public int Eficaz { get; internal set; }
    }

    public class Avaliacao
    {
        public bool IsAvaliado { get; set; }
        public bool IsAprovado { get; set; }
    }

    //Abstractions
    public interface IRuleHandler<Requisicao, Retorno> {
        IRuleHandler<Requisicao, Retorno> ProximaRegra (IRuleHandler<Requisicao, Retorno> handler);
        Retorno Rodar (Requisicao request);
    }

    public abstract class Regra<Requisicao, Retorno>  : IRuleHandler<Requisicao, Retorno> where Retorno : class {
        private IRuleHandler<Requisicao, Retorno> _proximaRegra;

        public IRuleHandler<Requisicao, Retorno> ProximaRegra (IRuleHandler<Requisicao, Retorno> regra) {
            _proximaRegra = regra;
            return regra;
        }

        public virtual Retorno Rodar (Requisicao request) => _proximaRegra?.Rodar(request);
        
    }

    //Request
    public class Requisicao {
        public bool Aprovar { get; }
        public Avaliacao Avaliacao { get; }
        public bool CriterioExiste { get; }
        public Eficacia Eficacia { get; }

        public Requisicao () {

        }
    }

    //Result
    public class Label
    {
        protected Label(string Result)
        {
            this.Valor = Result;
        }

        public string Valor { get; }

        public static Label AprovadoOn() => new Label("aprovadoOn");
        public static Label AprovadoOff() => new Label("aprovadoOff");
        public static Label ReprovadoOn() => new Label("reprovadoOn");
        public static Label ReprovadoOff() => new Label("reprovadoOff");
    }



    public class AvaliacaoInexistente : Regra<Requisicao, Label> {

        public override Label Rodar(Requisicao request)
        {
            var avaliacao = request.Avaliacao;
            
            if(avaliacao == null)
            {
                return avaliacao.IsAvaliado
                        ? request.Aprovar
                            ? avaliacao.IsAprovado
                                ? Label.AprovadoOn()
                                : Label.AprovadoOff()
                            : !avaliacao.IsAprovado
                                ? Label.ReprovadoOn()
                                : Label.ReprovadoOff()
                        : avaliacao.IsAprovado
                            ? Label.AprovadoOff()
                            : Label.ReprovadoOff();

            } else {
                return base.Rodar(request);
            }
        }
    }

    public class CriterioInexistente : Regra<Requisicao, Label> {
        public override Label Rodar(Requisicao request)
        {
            if (!request.CriterioExiste) 
                return request.Aprovar ? Label.AprovadoOff() : Label.ReprovadoOff();
            else
                return base.Rodar(request);
        }

    }

    public class EficaciaInexistente : Regra<Requisicao, Label> {
        public override Label Rodar(Requisicao request)
        {
            if (request.Eficacia == null) 
                return request.Aprovar ? Label.AprovadoOff() : Label.ReprovadoOff();
            else
                return base.Rodar(request);
        }

    }

    public class Eficaz : Regra<Requisicao, Label> {
        public override Label Rodar(Requisicao request)
        {
             switch (request.Eficacia.Eficaz)
            {
                case 0:
                    return request.Aprovar ? Label.AprovadoOff() : Label.ReprovadoOn();
                case 1:
                    return request.Aprovar ? Label.AprovadoOn() : Label.ReprovadoOff();
                default:
                    return request.Aprovar ? Label.AprovadoOff() : Label.ReprovadoOff();
            }

        }

    }

    class Program {
        static void Main (string[] args) {

            var request = new Requisicao();

            var regras = new AvaliacaoInexistente()
                .ProximaRegra(new CriterioInexistente())
                .ProximaRegra(new EficaciaInexistente())
                .ProximaRegra(new Eficaz());

            var resultado = regras.Rodar(request);
            
            return resultado.Valor;
        }
    }


}