6 maneiras de fazer a mesma coisa, o que é considerado boas práticas?

As vezes tem tantas maneiras diferentes de fazer o mesmo código que nós ficamos na dúvida quanto a qual maneira usar. O que seria considerado "boa prática" pela comunidade e o que sua equipe entenderia melhor. Suponhamos que você esteja trabalhando dentro de um método de um Domain Service chamado UmDomainServiceChique(objetoDoDominio) que será chamado por uma API. Você tem uma regra de negócio chique para ser verificada que por enquanto chamarei de VerificaMinhaRegraChiqueComplexa(). Você chama UmDomainServiceChique(objetoDoDominio) e caso VerificaMinhaRegraChiqueComplexa() retorne true você vai querer que UmDomainServiceChique faça o que tem que fazer e a api retornar Ok 200, caso contrário você quer que a API responda um erro qualquer, tipo BadRequest, e retornar uma mensagem dizendo que VerificaMinhaRegraChiqueComplexa deu ruim. Eu vejo 6 maneiras de fazer isso, gostaria de saber a opinião de outrs devs sobre qual seria a maneira menos gambiarr

Domine a herança de construtores

Em hierarquias longas de objetos é importante saber onde colocar o código dos contructors (construtores) pois eles tem uma ordem lógica para executar e, se for um parameterless constructor (construtor sem parâmetros) então todos os parameterless constructors serão executados desde a raiz object.

Um parameterless constructor sempre executa o parameterless constructor da classe base (pai), mas um construtor com parâmetros você deve especificar:


  1. :this([parametros]) para executar um outro constructor na mesma classe e deixar a hierarquia seguir sucessivamente
  2. :base([parametros]) para executar um constructor específico da classe base
  3. NADA para executar o parameterless constructor da base.


O programa abaixo ilustra isso.


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HerancaConstrutor
{

    class ClasseBase
    {
        public ClasseBase()
        {
            Console.WriteLine("parameterless constructor da classe ClasseBase");
        }
    }

    class DerivadaSemConstructor : ClasseBase
    {
        
    }


    class DerivadaComConstructor : ClasseBase
    {
        public DerivadaComConstructor()
        {
            Console.WriteLine("parameterless constructor da classe DerivadaComConstructor");
        }

        public DerivadaComConstructor(string argumento)
        {
            Console.WriteLine("constructor com argumentos da classe DerivadaComConstructor. Argumento: " + argumento);
        }
    }


    class DerivadaDaDerivadaSemConstructor : DerivadaSemConstructor
    {
        
    }

    class DerivadaDaDerivadaComConstructor : DerivadaComConstructor
    {
        public DerivadaDaDerivadaComConstructor()
            : base("")
        {
            Console.WriteLine("parameterless constructor da classe DerivadaDaDerivadaComConstructor");
        }

        public DerivadaDaDerivadaComConstructor(string argumento) : base(argumento)
        {
            Console.WriteLine("constructor com argumentos da classe DerivadaDaDerivadaComConstructor. Argumento: " + argumento);
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            var v1 = new ClasseBase();

            var v2 = new DerivadaSemConstructor();
            var v3 = new DerivadaComConstructor();
            var v3b = new DerivadaComConstructor("b");

            var v4 = new DerivadaDaDerivadaSemConstructor();
            var v5 = new DerivadaDaDerivadaComConstructor();
            var v5b = new DerivadaDaDerivadaComConstructor("b");
        }
    }
}



Toda classe sem parameterless constructor padrão possui um parameterless constructor implícito herdado de object.
Toda classe com um parameterless constructor implicitamente executa o parameterless constructor da classe base, estando ele sendo chamado com :base() explicitamente ou não.

Se um constructor não é criado eecuta o parameterless constructor da classe base
se um constructor é criado mas não é definido um constructor base é executado o parameterless constructor da base.
se um construtor é criado e é especificado um outro construtor da classe base com argumentos para ser executado, é executado o constructor escolhido e o constructor da classe ancestral da base é executado.
Se um constructor chama outros constructors, com ou sem parâmetros, na classe atual ou na classe base, não importa, uma hora um constructor parameterless implícito ou explícito será executado.

Comentários

Postagens mais visitadas deste blog

Uso de memória no SQL Server

Busca de CEP com o Lazarus - Parte 1 - UrlEncode

Botão Add This para adicionar seu post em qualquer rede