Admittedly that's a bad title, but the full title would be far too long.
To give some context. I volunteer at a charity where I maintain a MSSQL Database and an MS Access client application and I'm currently in the process of completely overhauling and rewriting the existing system to use .NET applications and PowerShell modules.
The old system was simple enough, a folder filled with T-SQL scripts and a batch file to deploy it to the server, and the Microsoft Access file was 'version controlled' through the daily backups and an extra folder called 'backup' filled with tonnes of copies of the .accdb file with a timestamp appended to the file name. (Please don't hate me.)
The overhaul currently consists of one Visual Studio solution with all of my projects inside that solution. Now some of these projects are dependent on other projects and others are completely standalone. Excluding the other folders i.e. documentation, binaries, dependencies, this is how my solution looks in Visual Studio:
- Main Solution File
- WPF Application (dependent on Class Library 1)
- Class Library 1 (dependent on Class Library 2)
- Class Library 2 (dependent on Class Library 3)
- Class Library 3
- Unit Test Project (dependent on Client Application)
- WCF Service Library (discontinued and unloaded)
- Powershell Module Project
- SQL Server Database Project
(as an aside, this is all contained in one big Git repository with the dependencies, documentation, etc.)
To me, this seems like a really bad idea because any new libraries, applications or PS projects I might need to create would end up in this solution.
Also, When I'm working with version control branches I end up borking my builds because the versions of each project end up out of sync. i.e. If I work on the database branch and change something and then go back to the client branch, the database changes aren't reflected. To get everything up to date, I'd go absolutely merge-crazy.
Are there any 'best practices' regarding organising large projects like this? I can understand trying to keep everything in one place and related projects together but at the same time part of me thinks they need to be split into separate solutions (as well as separate Git repositories).
Edit: I've read the duplicate question and now understand why keeping all projects in one solution is a good idea. Now I just need to understand how to work with separate branches which depend on other projects.
As an example, Let's say I switch to the 'database' branch and change the structure of the database. I then might need to make the client aware of the changes I've made, so I switch to the 'client' branch, but because I made changes on another branch, the client branch has no idea those changes have been made. How do I address that? The only ways I can see to do it is:
- Make the application changes in the database branch.
- Merge the database branch into master first, and then make changes in the client branch.
