Flera objekt som skriver data: Hur man undviker detta

Du vet de tillfällen då du arbetar med ett program, och det finns vissa ställen i din kod som, beroende på kraven eller en bugg som visar sig på något sätt, är direkt relaterade till det faktum att du har flera objekt som skriver data till samma datalager? Det är inte bra.

Det är ett hemskt sätt att starta ett inlägg. Låt mig försöka igen.

Flera objekt som skriver data

Säg att du arbetar med ett program och en av sakerna som koden gör är att uppdatera en räknare någonstans i databasen för att spåra hur många ändringar som har skett under en kort tidsperiod.

Problemet: Du har flera platser i koden som uppdaterar den här räknaren.

Flera objekt som skriver data (ifall min handstil är så oläslig som den verkar).

Jag tror inte att många av oss tänkte skriva sådan här kod, men det händer, och när det gör det slutar det med att få alla dessa biverkningar som bara föder upp alla typer av funky beteende. (Jag vet inte den officiella, akademiska termen för det – och jag menar inte DRY – men jag är okej med "funky beteende" för det här inlägget.)

Vi vet intuitivt att vi borde ha en enda plats där allt detta händer, externa faktorer – vare sig det är omfattningskrypning, ett missförstånd från vår sida för att förstå kraven eller vad som helst – föder dålig kodning.

Så då har vi alla dessa enheter i hela vårt system som var och en pratar med en enda punkt i vår databas (eller vilket datalager du vill), men ingen av dem är medveten om att andra talar till dem.

Sätt upp gränser

Vi kan försöka bekämpa detta med villkor och vad inte, men vi gör det bara värre. Så vad ska vi göra?

Jag vet, som med många saker inom programmering, det finns en mängd olika sätt att lösa detta på, men kanske är ett av de första stegen av refactoring att ha en klass som ansvarar för att utfärda uppdateringar till datalagret.

På så sätt kan vi gå från illustrationen ovan till något så här:

Flera objekt som skriver data: Skicka den till en sorts medlare.

Det vill säga alla entitetsgemenskaper med detta objekt och det här objektet – och endast detta objekt kan läsa och skriva data till databasen.

Det finns några designmönster som skulle passa just detta problem, men det ligger utanför ramen för detta inlägg. Istället, poängen som jag försöker göra är att om du befinner dig inför ett problem av:

• Entiteter skriver data till datalagret,
• Flera enheter gör det,
• Och det föder oavsiktliga konsekvenser,

Försök sedan att skapa en klass eller uppsättning klass som är strikt ansvarig för att läsa och skriva data. Låt bara informationen passera genom dessa klasser istället för att ha flera klasser gör datamanipulationen.

Det gör det lättare att testa, det gör det lättare att felsöka, och det gör det i slutändan lättare att läsa.