Large scale C# development

[Ivan Krivyakov]

Let's say I have a big system with several dozen C# projects - some
of them class libraries, some of them applications. Executables and
libraries from higher layers depend on libraries from lower layers.

The system usualy has two builds: debug build and release build.
Debug libraries and executables depend on other debug libraries,
and release libraries and executables depend on release libraries.

The question is: how do I accomplish this without building one huge
solution file with a lot of projects?

As far as I understand, for each C# project I must specify its
references.

There are two type of references - regular references and project references.
Regular references can reference only a single DLL. There is no way to
distinguish between Debug and Release. Project references behave the
way I want - Debug build will reference Debug library, and Release build
will reference Release library, but they assume target project is in the
same solution as my current project.

Thus, if I want to use project references, it will lead to a huge .sln file
with dozens of projects in it. Such file is very difficult to work with, because
of speed and memory problems.

In C++ world we solved this problem by creating smaller solution files
with just a couple of projects in each, and handling overall system dependencies
in a makefile, that invoked compilation of individual solutions.

But in C# I cannot do it because of project references.

What method to you use for your large-scale C# system?

Thanks in advance,
Ivan Krivyakov

[Randy A. Ynchausti]

Ivan,

As far as I understand, for each C# project I must specify its
references.

Build "smaller" assemblies and install them in the GAC.

Regards,

Randy

[Yura2000]

You may use kind of setup project called ReferenceCollector
(for instance).
All what he will do - compile needed DLLs ant output them
into defined place - same place for all developers.

-----Original Message-----
Let's say I have a big system with several dozen C# projects - someof them class libraries, some of them applications. Executables andlibraries from higher layers depend on libraries from lower layers.
The system usualy has two builds: debug build and release build.Debug libraries and executables depend on other debug libraries,and release libraries and executables depend on release libraries.
The question is: how do I accomplish this without building one hugesolution file with a lot of projects?

As far as I understand, for each C# project I must specify itsreferences.

There are two type of references - regular references and project references.Regular references can reference only a single DLL. There is no way todistinguish between Debug and Release. Project references behave theway I want - Debug build will reference Debug library, and Release buildwill reference Release library, but they assume target project is in thesame solution as my current project.

Thus, if I want to use project references, it will lead to a huge .sln filewith dozens of projects in it. Such file is very difficult to work with, becauseof speed and memory problems.

In C++ world we solved this problem by creating smaller solution fileswith just a couple of projects in each, and handling overall system dependenciesin a makefile, that invoked compilation of individual solutions.
But in C# I cannot do it because of project references.

What method to you use for your large-scale C# system?

Thanks in advance,
Ivan Krivyakov
.

[Ivan Krivyakov]

"Yura2000" <yu***@clal-ins.co.il> wrote in message news:0b****************************@phx.gbl...

You may use kind of setup project called ReferenceCollector
(for instance).
All what he will do - compile needed DLLs ant output them
into defined place - same place for all developers.

How do you deal with Debug/Release problem?
Same question goes to Randy.

Ivan

[Flare]

> How do you deal with Debug/Release problem?

Same question goes to Randy.

I have very much the same "problem" so im listening....

Anders