Focus on Microsoft Technologies - Tutorials, Articles, Code Samples.

Wednesday, August 30, 2006

Introduction to .NET Assemblies

What is an assembly?

·         An Assembly is a  logical unit of code

·         Assembly. a collection of class modules presented as a single DLL or EXE file.

·         Assembly physically exist as DLLs or EXEs

·         One assembly can contain one or more files

·         The constituent files can include any file types like image files, text files etc. along with DLLs or EXEs

·         When you compile your source code by default the exe/dll generated is actually an assembly

·         Unless your code is bundled as assembly it can not be used in any other application

·         When you talk about version of a component you are actually talking about version of the assembly to which the component belongs.

·         Every assembly file contains information about itself. This information is called as Assembly Manifest.


What is assembly manifest?

·         Assembly manifest is a data structure which stores information about an assembly

·         This information is stored within the assembly file(DLL/EXE) itself

·         The information includes version information, list of constituent files etc.

·         Display metadata of one of your .NET programs or libraries by the use of the ILDASM tool

·         We can see the assembly's metadata with all the methods and types in a tree representation. If we click on ' M A N I F E S T ' we get a window, which shows the manifest information. Even if there are a lot of non well readable lines, we are able to identify version information and all the referenced assemblies used to run the displayed executable or library.

·         Why does the tool we have used right now call ' Intermediate Language Disassembler ' ? Just bring back into our minds that if we compile sources, for instance with the CSharp Compiler (CSC) or any other .NET language compiler, we won't get machine code executable on a computer. Instead we get Microsoft Intermediate Language (MSIL) or shortened to Intermediate Language (IL) stored as an EXE file. To get machine code and to run the EXE we need the Common Language Runtime (CLR) part of the .NET installation somewhere on our computer.



What is private and shared assembly?

The assembly which is used only by a single application is called as private assembly. Suppose you created a DLL which encapsulates your business logic. This DLL will be used by your client application only and not by any other application. 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.


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:


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.


How do I create shared assemblies?

Following steps are involved in creating shared assemblies :


·         Create your DLL/EXE source code

·         Generate unique assembly name using SN utility

·         Sign your DLL/EXE with the private key by modifying AssemblyInfo file

·         Compile your DLL/EXE

·         Place the resultant DLL/EXE in global assembly cache using AL utility


How do I create unique assembly name?

Microsoft now uses a public-private key pair to uniquely identify an assembly. These keys are generated using a utility called SN.exe (SN stands for shared name). The most common syntax of is :


sn -k mykeyfile.key


Where k represents that we want to generate a key and the file name followed is the file in which the keys will be stored.


How do I sign my DLL/EXE?

Before placing the assembly into shared cache you need to sign it using the keys we just generated. You mention the signing information in a special file called AssemblyInfo. Open the file from VS.NET solution explorer and change it to include following lines :




Now recompile the project and the assembly will be signed for you.


Note : You can also supply the key file information during command line compilation via /a.keyfile switch.


How do I place the assembly in shared cache?

Microsoft has provided a utility called AL.exe to actually place your assembly in shared cache.


AL /i:my_dll.dll


Now your dll will be placed at proper location by the utility.


Hands On...

Now, that we have understood the basics of assemblies let us apply our knowledge by developing a simple shared assembly.


In this example we will create a VB.NET component called SampleGAC ( GAC stands for Global Assembly Cache). We will also create a key file named sample.key. We will sign our component with this key file and place it in Global Assembly Cache.


Step 1 : Creating our sample component

Here is the code for the component. It just includes one method which returns a string.


imports system namespace BAJComponents             public class Sample                 public function GetData() as string                                     return "hello world"                 end function    end class end namespace

Step 2 : Generate a key file

To generate the key file issue following command at command prompt.


sn -k sample.key

This will generate the key file in the same folder


Step 3 : Sign your component with the key

Now, wee will sign the assembly with the key file we just created.


vbc sampleGAC.vb /t:library /a.keyfile:sample.key

Step 4 : Host the signed assembly in Global Assembly Cache

We will use AL utility to place the assembly in Global Assembly Cache.


AL /i:sampleGAC.dll

After hosting  the assembly just go to WINNT\Assembly folder and you will find your assembly listed there. Note how the assembly folder is treated differently that normal folders.



Step 5 : Test that our assembly works

Now, we will create a sample client application which uses our shared assembly. Just create a sample code as listed below :


imports system imports BAJComponents public class SampleTest     shared sub main()                   dim x as new sample                         dim s as string="x".getdata()              console.writeline(s)     end sub end class

Compile above code using :


vbc sampletest.vb /t:exe /r:<assembly_dll_path_here>

Now, copy the resulting EXE in any other folder and run it. It will display "Hello World" indicating that it is using our shared assembly





One reason that COM dumped everything into the Windows system directory was to make a single copy available to any program that needed it. This works for components that are used by a lot of different programs (unless you run into the problem of incompatible versions, DLL Hell, mentioned earlier). But even if no other program references a unique component developed for just one system, you have to do it the same way when you use COM. A big improvement in .NET architecture is that it recognizes that this just isn't necessary. .NET lets you simply store the components where you want to, usually in the directory with your application executable.


For components that really do need to be shared by a lot of other programs, you can create just one copy in the GAC, or Global Assembly Cache. I explained how to use GACUTIL, the GAC Utility, in the About Visual Basic article GACUTIL - Sharing your work in the Global Assembly Cache. .NET keeps track of different versions here too. And Windows even gives you a customized display of the GAC. In the Windows Explorer view of the GAC, the subdirectory structure is hidden and the Paste option isn't even available because you must "install" an assembly in the GAC after it has been given a "strong name".




Introduction Reflection

Reflection is ability to find information about types contained in an assembly at run time. Prior to .NET languages like C++ provided such ability in a limited sense. .NET provides a whole new set of APIs to introspect assemblies and objects. All the APIs related to reflection are located under System.Reflection namespace. .NET reflection is a powerful mechanism which not only allows you to inspect type information but also allows you to invoke methods on those types at runtime. Certain reflection APIs also allow creating of assembly in memory dynamically and use it in your code.


Getting started

The first thing you should do while using reflection classes is to include System.Reflection namespace.


using System.Reflection;


Loading an assembly

Before obtaining any information about types contained in an assembly we must first load the assembly.


Assembly myassembly = Assembly.LoadFrom("employee.dll");


This statement loads an assembly called employee.dll. You can substitute your own path here. Assembly class has a static method called LoadFrom that loads the specified assembly in memory. The method returns an instance of assembly class itself.


obtaining details about types from the assembly

The next step is to obtain a list of various types contained in the assembly.


Types mytypes[] = myassembly.GetTypes();Type




There are two methods to get type information . The method GetTypes returns an assay of System.Type objects. The method GetType returns a type object having details of specified object. Note that in our example Company is the namespace. In case your assembly do not contain any namespace you will simply write the type name.


Obtaining type details     

The Type class has following properties that gives details about the type under consideration :


Name : Gives name of the type

FullName : Give fully qualified name of the type

Namespace : Gives namespace name




IsCOMObject : Indicates if the type is a COM object




All the property names are self-explanatory and need no separate explanation.


obtaining details about methods, properties and fields

Each type may have fields (member variables), properties and methods. The details about each of these types are obtained by following methods of the Type object.


GetMembers() : Gives array of MemberInfo objects

GetFields() : Gives array of FieldInfo objects

GetProperties() : Gives array of PropertyInfo objects

GetMethods() : Gives array of MethodInfo objects


Note that you can also get information about specific method, property or field using GetMethod("mymethod"), GetProperty("myprop") or GetField("myfield") methods.


MethodInfo[] mymethods= mytype.GetMethods();

MethodInfo mymethod = mytype.GetMethod("GetSalary");


Invoking a method on a type

We have seen how to get information about various types from an assembly. Reflection also allows us to create instances of these types and invoke methods on them. Following code fragment shows just that.


Assembly a=Assembly.LoadFrom("employee.dll");


Type t=a.GetType("Company.Employee");                                                                        


MethodInfo getsalary=t.GetMethod("DisplayMsg"); object




object[] p=new object[1]; p[0]="Hello bipin";




Here, we first obtained type of employee class. We then created an instance of it using Activator.CreateInstance() method.  There are two forms of Invoke() method :


If your method is not returning any value then you may use following form

Invoke ( obj , obj[])

If your method is returning some value and you want to trap it use following form :

obj = Invoke ( obj , bindingflag, binder , parameters, cultureflag )

For both the forms you pass instance of object on which the method will be called and array of objects that contains method parameters.


Reflection allows a powerful mechanism to introspect your types. The reflection APIs can be found in System.Reflection namespace. The APIs allow you to inspect types as well as create types on the fly and invoke methods on them.

Post a Comment