I want to create two applications that will have a lot of common functionality. Basically, one system is a more advanced version of the other system. Let's call them
Advanced system will add to, extend, alter and sometimes replace the functionality of the
Simple system. For instance, the
Advanced system will add new classes, add properties and methods to existing
Simple classes, change the behavior of classes, etc.
Initially I was thinking that the
Advanced classes simply inherited from the
Simple classes but I can see the functionality diverging quite significantly as development progresses, even while maintaining a core base functionality. For instance, the
Simple system might have a Project class with a Sponsor property whereas the
Advanced system has a list of Project.Sponsors. It seems poor practice to inherit from a class and then hide, alter or throw away significant parts of its features.
An alternative is just to run two separate code bases and copy the common code between them but that seems inefficient, archaic and fraught with peril. Surely we have moved beyond the days of "copy-and-paste inheritance".
Another way to structure it would be to use partial classes and have three projects:
Core which has the common functionality,
Simple which extends the
Core partial classes for the simple system, and
Advanced which also extends the
Core partial classes for the advanced system. Plus having three test projects as well for each system. This seems like a cleaner approach.
What would be the best way to structure the solution/projects/code to create two versions of a similar system? Let's say I later want to create a third system called
Extreme, largely based on the
Advanced system. Do I then create an
AdvancedCore project which both
Extreme extend using partial classes? Is there a better way to do this?
If it matters, this is likely to be a C#/MVC system but I'd be happy to do this in any language/framework that is suitable.