dependencies - NuGet Dependency Hell -

I have a small question that is related to our own Nugget Server and Nuggets packages, which we are motivating for it We have a number of projects and an optimized TFS manufacturing process that is automatically moving the NuGet package onto our newgate server - so far it is working very well.

We are currently asking that this is a good solution: Our main project is using dependency injection to solve dependencies so we have a project structure:

<

Interface (.dl)

DataLayer (.dl)

Localization (.dl)

Infrastructure (.dl)

Application (.xa)

In my opinion I would like to divide things into smaller resolutions Simple and easy to use:

• Interface (only one project: interface definitions)
• Compontents (three projects: with datelare, localization and basic features)
• Application (only one project: XE only)

This leads us to the problem that if an interface is changing, then we need to update the NewJet-packet version The interface inside the project of each component, in our build system After making the changes, and then update the application. It's like a little DLL Hal - in addition to this, debugging and developing is a bit tricky if you try that many projects have been separated.

Is this structure nonsense? What is a good option for you to solve dependency in your opinion and reduce and open large solutions in small people? Or would you suggest consolidating all the projects into a big solution?

From the perspective you are recommending "If any interface is changing, The NuGat-Packet Edition of the interface will need to be updated, our build system will make changes "is not really the best practice and problems on your scale will arise.

Ideally, you want to separate the development of the package with the development of the consumer. Consider your component package and application layer. If you have current set up where application project is using 1.0.0.0 of your component package. Any component component adds a new component to the package and creates a version 1.1.0.0. Now if you update the component package in the application project and update it, the following things will happen

1. Any bug fixes included in the new components package (which is a good thing
2. Any new components added to the package will be available for the application project (this is a good thing if the application is to consume the new component and does not affect the application at all )
3. Oi was new bug that could affect the performance of existing components inadvertently which was added in the process of creating new components.

In my opinion, the point # 3 package is the most dangerous effect of the update, whenever I know that the new version of the package is going to fix a bug or present new functionality I need an application, so I'm fine in fixing the risk of adding new bugs. However, if I am not using new components, then I can basically introduce instability in the application project for no extra benefit.

I would suggest the process-

1. Separate the development of each package from its consumer. This approach is very well scalable and gives consumers choices of new options in the alternative is.
2. Create some systems / conferences where developers of the package can tell the customer when a new version is being released. Proper release notes / a simple blog can also be enough.
3. Drag the new package into the latest version of the application / projects when it has the required functionality by the consumer