Gelukkig, ik ben niet de enige gek die op vrijdag om 7:00 achter zijn computer plaatsneemt
Gisterenavond even een
klein refactoring slagje gedaan in een .NET projectje. Een functie was inmiddels uitgegroeid tot een kleine 700 regels

Daar kwam ik nu pas achter, steeds wordt er een stukje toegevoegd maar nooit gelet op de lengte en complexiteit van de functie. De 700 regels bestaan nog wel, maar zijn nu tenminste een beetje gegroepeerd. Soms is refactoring best dankbaar werk
Overigens liep ik wel tegen iets aan waar ik niet echt wist wat de beste oplossing is, er is vast wel iemand die een gooi naar de prijzen wil doen.
Ik heb een functie waar een class Reaction in wordt verwerkt. In de reactie staan 1 of meerdere velden die uiteindelijk moeten mappen naar een structuur. De Reaction wordt extern aangeleverd en is "plat" terwijl dat de bestemming een relationele set is. Ieder veld in reaction bevat een "mapping" markering waarmee bepaald wordt hoe er gemapped wordt, staat er RelatieNaam wordt in relatie de naam gevuld, hier is logica voor. De logica om dit te doen (de case boom met daarin logica per element) zat eerst in de grote functie, maar is nu dus verhuisd naar een ander plekje. In principe kun je de volgende oplossingen kiezen:
- Een functie die een class/array teruggeeft met daarin de relationele dataset objecten, nadeel is dat je naderhand alles weer terug moet lezen. Daarnaast zijn de datasets voor deze aanroep ook al "aangeraakt". Er moet dus data in en er moet data uitkomen.
- Een functie per bestemmings object (dus MapReactionToRelation, MapReactionToContactPerson), nadeel is dat je veel functies krijgt en je loopt het risico dat er uiteindelijk een bepaalde mapping niet goed staat opgenomen en je dus niet goed meer mapped
- Een functie die het Reaction object omzet naar alle objecten en deze via de parameters teruggeeft, het zijn allemaal reference types dus opzich moet dat kunnen
Ik heb voor de laatste gekozen en geef de objecten dus in de parameters mee, voor de zekerheid heb ik ze even met "ref" gemarkeerd (want als ik later besluit een nieuw opbject te maken in de functie komt deze in dat geval alsnog goed terecht). Hoe zouden jullie zoiets oplossen?
1 had nog als nadeel dat je verwarring kunt scheppen, iemand die de functie aanroep gaat er over het algemeen vanuit dat wat hij erin stopt niet wordt aangepast (zeker niet als je een return value hebt). Dat is dus tevens de reden waarom ik mijn objecten expliciet als ref heb gemarkeerd, zo is in ieder geval duidelijk wat er gebeurt.
2 sluit inprincipe aan op de regel dat een functie slechts 1 ding mag doen, dat is in dit geval "vullen van Relatie aan de hand van Reactie", de andere doen in principe ook 1 ding, maar zitten op een wat "hoger" niveau ("vul structuur aan de hand van Reactie"). Daarbij komt dat in sommige gevallen de afhandeling van een veld in de reactie wordt gedaan aan de hand van een waarde in een van de reeds gevulde objecten of dat 2 objecten tegelijk worden gevuld met een bepaalde waarde, optie 2 zou daardoor vrij lastig worden om te implementeren.
Hopelijk zien jullie het niet als vraagbaak-vraag, vind het zelf niet schokkend genoeg om een nieuw topic aan te maken, ben gewoon benieuwd wat de die-hards hier zouden verzinnen