In these cases, Is the build for all the modules is necessary?

  • Thread starter Thread starter Guest
  • Start date Start date
G

Guest

Hello, I have a question.
I have a big project, and all the modules are over 100, some of dll was
referenced by most of the modules (dll, exe)
When one EXE call a DLL, if some functions in the DLL was modified, for
example: fix some bugs, usually all the modules will be recompiled, but
because we have too much modules, if we do the build, all of the modules need
to be update to the customs to maintenance the version.
So I want to know if we only add a new function or add some variants to the
DLL, whether we must build all of the modules?

For examples:
There are over 50 applications call one DLL
In the DLL:
1. add a new method or function, and only one APP need this function, so we
want to compile only the one APP and one DLL;
2. add a new Variants, and only one APP need this function, so we want to
compile only the one APP and one DLL;
3. change the interface of one function in the DLL(change the variant type
or add more parameters), and we are sure only one APP will be effected, so we
want to compile only the one APP and one DLL;
4. change the return type of function(from Boolean to Int32), and we are
sure only one APP will be effected, so we want to compile only the one APP
and one DLL;
5. Change from private to public, and also we are sure only one APP will be
effected, so we want to compile only the one APP and one DLL;

And in these cases, Is the build for all the modules is necessary? If we
don’t do it, what kind of impact we will have?

Thanks
 
isamusetu said:
Hello, I have a question.
I have a big project, and all the modules are over 100, some of dll
was referenced by most of the modules (dll, exe)
When one EXE call a DLL, if some functions in the DLL was modified,
for example: fix some bugs, usually all the modules will be
recompiled, but because we have too much modules, if we do the build,
all of the modules need to be update to the customs to maintenance
the version. So I want to know if we only add a new function or add
some variants to the DLL, whether we must build all of the modules?

For examples:
There are over 50 applications call one DLL
In the DLL:
1. add a new method or function, and only one APP need this function,
so we want to compile only the one APP and one DLL;
2. add a new Variants, and only one APP need this function, so we
want to compile only the one APP and one DLL;
3. change the interface of one function in the DLL(change the variant
type or add more parameters), and we are sure only one APP will be
effected, so we want to compile only the one APP and one DLL;
4. change the return type of function(from Boolean to Int32), and we
are sure only one APP will be effected, so we want to compile only
the one APP and one DLL;
5. Change from private to public, and also we are sure only one APP
will be effected, so we want to compile only the one APP and one DLL;

And in these cases, Is the build for all the modules is necessary? If
we don’t do it, what kind of impact we will have?
Click to expand...

If you're changing an interface, it's best to use a new version for
your DLL. By using strong named assemblies (signed assemblies) you can
achieve that one application uses version 1.0.0.0 and another uses
1.0.0.1

Don't cram too much projects in one solution. It's best to keep
versions of libraries apart from the .exe's. This way versioning is
easier.

Though, the more you version differently, the more maintenance you
create as well, which can be a problem as well. Which can lead to
another solution to the problem: first keep the libraries separated
from the .exes (as stated above), then if you alter an interface,
create a NEW interface which derives from the old one and only use that
interface in the app which needs the interface change. Still this is
problematic if you have a lot of interface changes, though for rare
revisions this cna be a solution.

In any case: plan your revisions wisely. Agile development on
libraries which are shared among a lot of .exe's is not very wise, as
you'll break a lot of apps when changing a library's interface, unless
you thouroughly test everything through and send new builds to clients,
something you want to avoid if I understand your message correctly.

FB


--
 
Thank you for your answer.

So your suggestion is it's better compile all the modules if we change the
interface.
Right?
 
Back
Top