Un calcolatore dovrebbe essere un tipo di valore o un tipo di entità?

Question

Un calcolatore dovrebbe essere un tipo di valore o un tipo di entità?

#1 da (3 voti)
#2 da (1 voti)
#3 da (0 voti)

-3

Vedi il codice qui sotto:

public class Calculator
    {
        private readonly int Number1;
        private readonly int Number2;
        private readonly int Answer;

        public Calculator(int _Number1, int _Number2)
        {
            Number1 = _Number1;
            Number2 = _Number2;
            Add();
        }

        public void Add()
        {
            Answer = Number1 + Number2;
        }

    }

Il codice sopra errori come previsto perché sto cercando di inizializzare un campo di sola lettura al di fuori del costruttore. Mi rendo conto che l'unica riga di codice in "Aggiungi" potrebbe essere spostata nel costruttore per farlo funzionare. Tuttavia, aggiungere Add è stata una funzione molto complessa.

Q1) La classe Calculator dovrebbe essere immutabile? Q2) Se la risposta a Q1 è 'Sì', allora tutto il codice per la funzione 'Aggiungi' va nel costruttore (facendolo sembrare un disastro - assumendo che 'Aggiungi' abbia più di 1 riga di codice - diciamo che ha 30 righe di codice).

Sto parlando rigorosamente da una prospettiva DDD (best practice). Mi rendo conto che posso spostare solo una riga di codice dal metodo Add al costruttore in questo caso.

unit-testing c# domain-driven-design

posta w0051977 15.06.2017 - 09:13

fonte

3 risposte

Leggi altre domande sui tag unit-testing c# domain-driven-design

Perché un'espressione per una funzione Javascript che restituisce void viene ancora eseguita? [chiuso] Demo versus Prototipo [chiuso]

score 3 · Answer 1

Il nome Calculator è leggermente fuorviante, poiché l'oggetto contiene non solo l'operazione di calcolo, ma anche l'input e il risultato di un singolo calcolo. Quindi un nome più adatto sarebbe Calculation , poiché l'oggetto rappresenta davvero un singolo calcolo.

La denominazione potrebbe sembrare un nitpick, ma in realtà è importante poiché ci fa chiarire lo scopo della classe. Una classe che rappresenta un singolo calcolo sarebbe naturalmente immutabile, poiché se fosse stata modificata non sarebbe più lo stesso calcolo e, cosa più importante, se l'input o il risultato fossero cambiati indipendentemente, il calcolo non sarebbe più corretto! Quindi sembra decisamente ragionevole.

Non è necessario avere tutta la logica di calcolo nel costruttore anche se immutabile. Potresti avere Add essere un metodo statico che restituisce il risultato. Sarebbe molto bello separare l'operazione di calcolo in un metodo puro.

score 1 · Answer 2

L'immutabilità non ha nulla a che fare con le linee di codice. Se la classe può essere immutabile, allora con tutti i mezzi, andare avanti e renderla immutabile. Ogni opportunità di rendere immutabile una classe dovrebbe essere perseguita con tenacia. Di conseguenza, se il tuo costruttore sarà lungo 100 righe, così sia. E, per inciso, non è quasi mai necessario realizzare un metodo lungo 100 linee. Puoi fare qualcosa di simile, ad esempio:

public class Calculator
{
    private readonly int Number1;
    private readonly int Number2;
    private readonly int Answer;

    public Calculator(int _Number1, int _Number2)
    {
        Number1 = _Number1;
        Number2 = _Number2;
        Answer = Add();
    }

    private int Add()
    {
        return Number1 + Number2; //plus 30 lines of code
    }
}

score 0 · Answer 3

In questo caso, Calculator sembra essere più di un servizio, non un Value object quindi non dovrebbe avere lo stato quindi l'immutabilità non ha senso per un servizio stateless.

Forse hai bisogno di rifattorizzarlo su qualcosa di simile:

public class Operand
{
    private readonly int Number;

    public Operand(int _Number)
    {
        Number = _Number;
     }

    private Operand Add(int _Number2)
    {
        return new Operand( Number + _Number2);
    }
}