This happens regularly to me (and from my anecdotal investigation everyone involved in large / old projects). We need a new piece of functionality. I write it, it's beautiful and I win the internet. I have estimated 8 days (or 22.23 lol-points depending on how you live) and it's only taken 4 days.
Ah, but then a very small; mostly ignored and very unimportant detail rears it's cruel head. You need to make it work with the code that exists already. This is normally in the form of saving to some pre-existing entities. Oh dear. You save everything through the various management / service classes that exist already and nothing works. So begins the next couple of days of horror.
You find that you didn't set the
work = true. Most of my woes in this area are caused by modifications at layer further down (or the stored procedure it finally ends up in) changing the object that I was trying to save or not saving part of the object because of some rule.
So many errors are caused by objects being used and abused and then changed or properties being altered somewhere by someone you weren't expecting. I have a couple of tips to help try and mitigate these problems. Of course, as Devs this shouldn't happen, you should test everything, other people should test everything, it should pass code review and so on and so forth. However that's all well and good but you aren't in control of the future. You don't know what the level of skill of the devs who pick up your code base in the future will have and you don't know what procedures will be added / removed.
Keep classes sealed!
Don't let your class be abused by some future fiend. Unless you are writing something specifically as a base class, the likelihood of it needing to be inherited from is slim. More likely is that someone is trying to do some good old fashioned lazy code-reuse by inheriting your lovely class instead of refactoring the functionality. Of course if a genuine reason crops up the future for the inheritence.... er, just change it! But let the need drive what you do.
Make constructors internal
Stop your object being created in the wrong assembly by making the constructor internal. This way, you can retrieve the object from the repository but you can't create a random new object for who knows what. You might not always need to do this, but I like to allow a command object or other method of instruction to create an object, this keeps the knowledge of how the object is created and what business rules need to be applied out of the calling assembly.
Control how your properties are set
private set or use
public readonly fields that are set using the constructor. If you can at all, try to make changing an object once it exists, as difficult as possible unless your intention is for the property to change for a specific reason. The reason I love F# is that you have to specifically call a value mutable if you need it to change and it's discouraged.
Use an interface to control mutating an object
I stopped using this a couple of years ago as it seemed overkill but then recently we ran into problems of abuse again and although you can help people when you work somewhere and you can leave documentation and coding conventions you need to think about your legacy. Explicitly making the object be cast using the interface
(object as IEditableObject) means you can control how the object is updated. If you make the interface internal to the correct assembly too you can stop people just getting an object out of the database, saving it and bypassing any logic that should have been applied.