Assemblies In .NET Application

In this article, I am going to explain about assemblies in .NET. Also, we will see how we can create assembly with a strong name. This article will help you understand the assembly, deeply.

Topics that I am going to cover in this article:

  • What are Assemblies ?
  • Types of Assemblies.
  • Managing Assemblies in Global Assembly Cache.
  • Generating a Public Key.
  • Creating a Shared Assembly.
  • Versioning of Assembly.

Let’s Start

What is Assembly in .NET?

Assemblies are the core building blocks of .NET applications. In simple terms, assembly is the .dll or .exe file that is created while building any .NET application. You can find many definitions for assembly over the internet also. In my point of view, assembly is the building block which is created after a successful build operation of your application.

In every project, after compilation, an output file is generated, known as Assembly. The name of an assembly file is the same as the project name. The assembly corresponding to a project remains present under bin\Debug folder of that project folder. Assemblies are known as units of deployment because once the project development is completed, what we carry and install on the client systems is the assembly files only. The extension of an assembly file uses to be either .exe (executable) or .dll (dynamic link library).

Windows Forms Applications, Console Applications, WPF Applications, and Windows Services projects generate an .exe assembly. Class Library and Windows Forms Control Library projects generate a .dll assembly.

Exe assemblies are known as in-process components which were capable of running on their own as well as provide the support for others to execute. When we work with project templates, like Windows Forms Applications, Console Applications, WPF Applications, and Windows Services, they generate an exe assembly when compiled.
Dll assemblies are known as out-process components which are not capable of running on their own. They can only support others to execute. When we work with project templates, like Class Library and Windows Forms Control Library, they generate a dll assembly when compiled.

Note: Every application is a blend of both .dll and .exe assemblies combined together to give better efficiency.
application

Types of Assembly:

In .NET, we have two types of assemblies:

  1. Private Assembly
  2. Shared Assembly

Private Assembly

By default, every assembly is private. If reference of these assemblies is added to any project, a copy of the assembly is created and given to that project, so that each project maintains a private copy of that assembly.

Private Assembly

Creating an assembly to test if it is private, by default:

Open a new project of type Class Library and name it as “PAssembly”, which will by default come with a class Class1 under the file Class1.cs. Now, write the following code under the class:

    public string TestHello() {
    return "Hello from private assembly";
    }

Now, compile the project by opening the Solution Explorer, right clicking on the project, and selecting “Build” which will compile and generate an assembly with the name as PAssembly.dll.

Note: We can find the path for our assembly in the output window present at the bottom of the Visual Studio after successful build.

code
Testing the assembly we have created

Open a new project of type Windows, name it as “TestPAssembly”, place a button on the Form, and set its text as “Call TestHello method of Class1 in PAssembly.dll”. Now, add the reference of PAssembly.dll from its physical location and write the following code under click of button:

    PAssembly.Class1 obj = new PAssembly.Class1();
    MessageBox.Show(obj. TestHello ());

Run the project to test it. Then, go and verify under bin/debug folder of current project where we can find a copy of PAssembly.dll as it is private assembly.

Note: The advantage of a private assembly is faster execution because it is available in the local folder, whereas its drawback is that multiple copies get created when multiple projects add the reference to consume it.

Shared Assemblies

If we intend to use an assembly among several applications, private assemblies are not feasible. In such cases, we can install it into a centralized location known as the Global Assembly Cache(GAC). Each computer where the common language runtime is installed, has this machine-wide code cache. The global assembly cache stores the assemblies specifically designated to be shared by several applications on the computer. All BCL assemblies are shared .dll assemblies only. So, we can find them under GAC. If an assembly is shared, multiple copies of the assembly will not be created, even if it is being consumed by multiple projects. Only a single copy, under GAC, serves all the projects.
Shared Assemblies

Note: Administrators often protect the Windows directory using an Access Control List (ACL) to control, write, and execute the access. Because the global assembly cache is installed in the Windows directory, it inherits that directory’s ACL. It is recommended that only users with Administrator privilege be allowed to add or delete files from the global assembly cache.

Managing assemblies in Global Assembly Cache

To manage assemblies in GAC, like install, un-install, and view, we are provided with a tool known as Gacutil.exe (Global Assembly Cache Tool). This tool is automatically installed with Visual. To run the tool, use the Visual Studio Command Prompt.

Where is VS Command prompt ?

Go to Start menu – click on Visual Studio folder – Inside this, you find VS Command prompt.

VS Command prompt

These utilities enable you to run the tool easily, without navigating to the installation folder. To use Global Assembly Cache on your computer: On the Taskbar, click Start –> All Programs –> Visual Studio. Click Visual Studio Tools and then click Visual Studio Command Prompt and type the following:

gacutil [/i | /u | /l] <assembly name>
/i: Install
/u: Un-install
/l: List

Note: Assemblies deployed in the GAC must have a strong name. When an assembly is added to the global assembly cache, integrity checks are performed on all files that make up the assembly.

What a Strong Name is ?

A strong name consists of the assembly’s identity – its simple text name, version number, and public key.

  1. Name: It is the name of an assembly used for identification. Every assembly by default has a name.
  2. Version: Software maintains versions for discriminating changes that have been made from time to time. As an assembly is also a software component, it will maintain versions. Whenever the assembly is created, it has a default version for it, i.e. 1.0.0.0, which can be changed when required.
  3. Public Key: As GAC contains multiple assemblies in it, to identify each assembly, it will maintain a key value for the assembly known as public key, which should be generated by us and associated with the assembly to make it Strongly Named.

You can ensure that a name is globally unique by signing an assembly with a strong name. In particular, strong names satisfy the following requirements:

Strong names guarantee the name uniqueness by relying on unique key pairs. No one can generate the same assembly name that you can. Strong names protect the version lineage of an assembly.

A strong name can ensure that no one can produce a subsequent version of your assembly. Users can be sure that a version of the assembly they are loading comes from the same publisher who created the version the application was built with.

Strong names provide a strong integrity check. Passing the .NET Framework security checks guarantees that the contents of the assembly have not been changed since it was built.

Generating a Public Key

To sign an assembly with a strong name, you must have a public key pair. This public cryptographic key pair is used during compilation, to create a strong-named assembly. You can create a key pair using the Strong Name tool (Sn.exe) from visual studio command prompt, as the following:

sn -k <file name>
E.g.: sn -k Key.snk

Note: The above statement generates a key value and writes it into the file “Key.snk”. Key pair files usually have .snk extension

Creating a Shared Assembly

Step 1: Generate a public key. Open VS command prompt, go into your folder and generate a public key as following: <drive>:\<folder> sn -k key.snk,

command prompt

Now, key.snk is successfully created inside Drive ‘E’.

Step 2: Develop a new project and associate the key file to it before compilation, so that the assembly which is generated will be Strong Named.

To do this, open a new project of type Class Library, name it as “SAssembly”, and write the following code under the class Class1:

  1. public string TestHello() {
  2. return “Hello from shared assembly 1.0.0.0”;
  3. }

code

To associate the key file we have generated with the project, open project properties window, select Signing tab on LHS which displays a CheckBox as “Sign the Assembly”, and select it. Now, in the ComboBox below select browse, select the key.snk file from its physical location which adds the file under Solution Explorer. Then, compile the project using “Build” option that will generate SAssembly.dll which is Strongly Named.

properties

project

Now, browse your folder and choose the key.snk file.

key.snk file

Click OK. Then, the key shows you inside the Visual studio.

key.snk file

key.snk file

Now, build the project; and it’s ready with the dll with key inside your Bin\debug folder .

Step 3: Install assembly into GAC by using the “Global Assembly Cache Tool”.

To install the assembly, open Visual Studio Command Prompt, go to the location where SAssembly.dll is present, and write the following:

<drive>:\<folder\SAssembly\SAssembly\bin\Debug> gacutil -i SAssembly.dll

Command Prompt

Again, open this in Admin mode and run the above command.

Command Prompt

Step 4: Testing the Shared Assembly.
Open a new project of type Windows, name it as “TestSAssembly”, place a button on the form, and set its text as “Call SayHello method of Class1 in SAssembly.dll 1.0.0.0”.

Shared Assembly.

Shared Assembly.

Now, add reference of SAssembly.dll from its physical location and write the following code under the click of button:

  1. SAssembly.Class1 obj = new SAssembly.Class1();
  2. MessageBox.Show(obj.TestHello());

Run the project, test it, and verify under bin/debug folder of current project where we will not find the only copy of SAssembly.dll as it is shared assembly.

project

Check inside project Bin/debug folder.

project Bin/debug folder

Versioning Assemblies

Every assembly is associated with a set of attributes that describe about general info of an assembly, like Title, Company, Description, Version etc. These attributes are under AssemblyInfo.cs file of each project. To view them, expand properties node under the project in Solution Explorer where we find AssemblyInfo.cs file. We can change values of any attribute as per our requirements. In bottom of the file, we find an attribute “AssemblyVersion”.

which is a combination of 4 values,

  • Major Version
  • Minor Version
  • Build Number
  • Revision

The default version of every assembly is 1.0.0.0; we can change the version no. of an assembly whenever we make modifications to the code under assembly.

This is all about .NET Assembly and their uses.

So, I think I have covered all the topics successfully.

Post your feedback

Sharing and Coding !!!

 

 

Advertisements

Graphical Notation Meaning Used in .Net App.

Icon Description Icon Description
Namespace Symbol
Namespace
Declaration Symbol
Method or Function
Class Icon
Class
Operator Symbol
Operator
Lollipop Interface Symbol
Interface
Property Symbol
Property
Structure Symbol
Structure
Field Icon
Field or Variable
Union Symbol
Union
Event Symbol
Event
Enumeration Symbol
Enum
Constant Icon
Constant
Type Definition Symbol
TypeDef
Enumerate Item Symbol
Enum Item
Visual Studio Module Symbol
Module
Map Item Symbol
Map Item
Extension Method Symbol
Extension Method
Declaration Symbol
External Declaration
Delegate Symbol
Delegate
Error Icon for Class View and Object Browser
Error
Exception Symbol
Exception
Template Symbol
Template
Map Symbol
Map
Error Exclamation Point Symbol
Unknown
Type Forwarding Symbol
Type Forwarding

Resource taken from MSDN

How to Write a Log in .Net Application.

In Application development environment we always require to track our application performance as well as error and bugs.To tracking bugs and error we always write the log in temporary folder.So today we are going to discuss how to write the log in .Net application.Writing log is not save our time as well as helps us to track our application in proper manner

Today in this blog i will tell you how to write the log using C# programming Language.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

class WriteLogFile
    {
        public static bool WriteLog(string strFileName,string strMessage)
        {
            try
            {
FileStream objFilestream =new FileStream(string.Format("{0}\\{1}", Path.GetTempPath(), strFileName)
,FileMode.Append, FileAccess.Write);
StreamWriter objStreamWriter = new StreamWriter((Stream)objFilestream);
objStreamWriter.WriteLine(strMessage);
objStreamWriter.Close();
objFilestream.Close();
return true;
            }
            catch(Exception ex)
            {
                return false;
            }
        }
    }

Call the above WriteLog() method any app and pass parameter it will write the Log automatically.

Security In MVC Video Part-1

Watch this Video to learn about Authentication and Types in Asp.net MVC.