S.O.L.I.D. i principi

Question

S.O.L.I.D. i principi

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

0

Ho una piccola domanda. Quale approccio è corretto nel contesto dei principi SOLID? 1 o 2?

Nel primo caso, il metodo "CreateTask" non restituisce l'oggetto Task, ma lo inserisce nell'elenco che accetta come argomento del metodo.

Nel secondo caso, il metodo "CreateTask" non accetta argomenti, ma restituisce un oggetto task che deve essere inserito nell'elenco di attività

1.

var tasks = new List<Task>();
CreateTask1(tasks);
CreateTask2(tasks);
CreateTask3(tasks);

private void CreateTask1(List<Task> tasks)
{
   // some other logic about new task object       
   tasks.Add(new Task());
}

private void CreateTask2(List<Task> tasks)
{
   // some other logic about new task object       
   tasks.Add(new Task());
}

private void CreateTask3(List<Task> tasks)
{
   // some other logic about new task object       
   tasks.Add(new Task());
}

2.

var tasks = new List<Task>();
tasks.Add(CreateTask1());
tasks.Add(CreateTask2());
tasks.Add(CreateTask3());

private Task CreateTask1()
{
   // some other logic about new task object
   return new Task();
}

private Task CreateTask2()
{
   // some other logic about new task object
   return new Task();
}

private Task CreateTask3()
{
   // some other logic about new task object
   return new Task();
}

design c# solid patterns-and-practices

posta Crazy Man 01.02.2018 - 14:34

fonte

3 risposte

3

Vorrei andare per l'opzione 3:

var tasks = new List<Task>
{
    CreateTask1(),
    CreateTask2(),
    CreateTask3()
};

~~Tuttavia, non sono chiaro in che modo la domanda si riferisce ai principi SOLID~~

Aggiorna

Riguardo al principio di responsabilità singola, l'opzione 1 è "è responsabile della creazione dell'oggetto e inserendolo nell'elenco". Questo significa che infrange il principio? No. Non si rompe più dell'opzione 2 con il suo "responsabile della creazione dell'oggetto e restituendolo indietro". Riformi questi come "inserisci un oggetto creato nella lista" o "restituisci un oggetto creato" e "e" scompare. La presenza di "e" in una descrizione della funzionalità di un metodo è un modo inaffidabile per valutare se ha una sola responsabilità.

L'opzione 1 è brutta in quanto comporta la mutazione di un parametro. L'opzione 2 è migliore, ma non fa un uso corretto delle funzionalità del linguaggio. Quindi vai con l'opzione 3.

risposta data 01.02.2018 - 14:43

fonte

1

I principi SOLID sono principi per la progettazione di software orientato agli oggetti. Il tuo esempio di codice non è orientato agli oggetti: è costituito da funzioni autonome e un codice di primo livello che non è nemmeno in una funzione. Per interpretare il codice in base a SOLID, è necessario sapere quale classe esegue queste operazioni per quale scopo e quali sono le responsabilità di base. A seconda di questi fattori, entrambi gli esempi potrebbero essere i migliori.

Si noti in particolare che il Principio di Responsabilità Unica non è interessato alle responsabilità dei singoli metodi, ma si applica a livello di classe o di modulo. Quindi non è applicabile a questi esempi di codice.

risposta data 01.02.2018 - 14:54

fonte

Leggi altre domande sui tag design c# solid patterns-and-practices

Collaborazione in team con Maven - Java EE La composizione può violare l'O in SOLID

score 2 · Accepted Answer

Sebbene SOLID sostenga il n. 2, dovresti anche riflettere da solo sui possibili cambiamenti futuri.

Che cosa succede se non desideri utilizzare un Elenco ? Di ', vuoi usare un SuperSpecialList o una Mappa ?

Che cosa succede se è necessario aggiungerlo a due elenchi?

Che cosa succede se quell'elenco è una coda con una lunghezza massima ed è piena?

Tutti questi argomenti sostengono anche il design n. 2.