Assembly: An Assembly is a logical unit of code. Assembly physically exists as
DLLs or EXEs. One assembly can contain one or more files.
When you compile your
source code, by default the exe/dll generated is actually an assembly. Unless
your code is bundled as assembly it cannot be used in any other application.
Every assembly file contains information about itself. This information is
called as Assembly Manifest.
The assembly which is
used only by a single application is called as private assembly. In order to
run the application properly your DLL must reside in the same folder in which
the client application is installed. Thus the assembly is private to your
application.
Suppose that you are
creating a general purpose DLL which provides functionality which will be used
by variety of applications. Now, instead of each client application having its
own copy of DLL you can place the DLL in ‘global assembly cache’. Such
assemblies are called as shared assemblies.
If an application installs DLL’s or OCX-Files to
the System32 directory, version conflicts might occur with other applications
using the same files. In this case, use the “AdminStudio Application Isolation
Wizard” to prevent such conflicts.
What is Global Assembly Cache?
Global assembly cache is nothing but a special disk folder where
all the shared assemblies will be kept. It
is located under <drive>:\WinNT\Assembly folder.
How assemblies avoid DLL Hell?
As stated earlier most of the assemblies are private. Hence each
client application refers assemblies from its own installation folder. So, even
though there are multiple versions of same assembly they will not conflict with
each other. Consider following example:
●
You created assembly Assembly1
●
You also created a client
application which uses Assembly1 say Client1
●
You installed the client in
C:\MyApp1 and also placed Assembly1 in this folder
●
After some days you changed
Assembly1
●
You now created another
application Client2 which uses this changed Assembly1
●
You installed Client2 in C:\MyApp2
and also placed changed Assembly1 in this folder
●
Since both the clients are
referring to their own versions of Assembly1 everything goes on smoothly
Now consider the case
when you develop assembly that is shared one. In this case it is important to
know how assemblies are versioned. All assemblies has a version number in the
form: major.minor.build.revision.
If you change the original assembly the changed version will be considered
compatible with existing one if the major and minor versions of both the assemblies
match. When the client application requests assembly the requested version
number is matched against available versions and the version matching major and
minor version numbers and having most latest build and revision number are
supplied.
Comments
Post a Comment