Più oggetti che scrivono dati: come evitarlo
Sai quelle volte in cui stai lavorando su un programma e ci sono alcuni punti nel tuo codice che, a seconda dei requisiti o di un bug che si manifesta in qualche modo, è direttamente correlato al fatto che hai più oggetti che scrivono dati nello stesso archivio dati? Non è una buona cosa.
È un modo terribile per iniziare un post. Fammi provare di nuovo.
Più oggetti che scrivono dati
Supponiamo che tu stia lavorando su un programma e una delle cose che fa il codice è aggiornare un contatore da qualche parte nel database per tenere traccia di quante modifiche si sono verificate in un breve periodo di tempo.
Il problema: hai più posizioni nel codice che stanno aggiornando questo contatore.
Più oggetti che scrivono dati (nel caso in cui la mia calligrafia sia illeggibile come sembra).
Non credo che molti di noi abbiano deciso di scrivere codice come questo, ma succede e quando lo fa finisce per avere tutti questi effetti collaterali che generano tutti i tipi di comportamenti stravaganti. (Non conosco il termine accademico ufficiale per questo – e non intendo SECCO – ma sto bene con "comportamento eccentrico" per questo post.)
Sappiamo intuitivamente che dovremmo avere un unico luogo in cui tutto questo sta accadendo, fattori esterni – che si tratti di un’insinuazione nell’ambito, un malinteso da parte nostra per comprendere i requisiti o qualsiasi altra cosa – generano scarsa codifica.
Quindi abbiamo tutte queste entità nel nostro sistema, ognuna delle quali sta parlando con un singolo punto nel nostro database (o qualsiasi archivio di dati che ti piace), ma nessuna di loro è consapevole che altri stanno parlando con loro.
Impostare i confini
Possiamo provare a combattere questo con condizionali e cosa no, ma stiamo solo peggiorando le cose. Allora cosa dovremmo fare?
So che, come per molte cose nella programmazione, ci sono una varietà di modi per risolvere questo problema, ma forse uno dei primi passaggi del refactoring è avere una classe responsabile dell’emissione degli aggiornamenti al datastore.
In questo modo, possiamo passare dall’illustrazione sopra a qualcosa del genere:
Più oggetti che scrivono dati: inviali a una sorta di mediatore.
Cioè, tutte le entità fanno comunità con questo oggetto e questo oggetto – e solo questo oggetto può leggere e scrivere dati nel database.
Ci sono alcuni modelli di progettazione che si adattano a questo particolare problema, ma questo esula dallo scopo di questo post. Invece, il punto che sto cercando di fare è che se ti trovi di fronte a un problema di:
- Le entità scrivono i dati nell’archivio dati,
- Più entità lo stanno facendo,
- E sta generando conseguenze non intenzionali,
Quindi prova a creare una classe o un insieme di classi strettamente responsabili della lettura e della scrittura dei dati. Lascia che le informazioni passino solo attraverso quelle classi piuttosto che avere più classi per la manipolazione dei dati.
Semplifica il test, semplifica il debug e, in definitiva, semplifica la lettura.