In this article we are going to look at Microsoft .NET Framework. This is the
newly established software development environment which helps developers to
develop applications quickly and gives optimum, efficient, scalable, performance
oriented applications in different languages like Visual Basic .NET, C#, ASP
.NET, and Jscript .NET etc...
of the .NET Framework
The .NET Framework is a new
computing platform that simplifies application development in the highly
distributed environment of the Internet.
NET Framework provides the
- Tools for developing software applications ,
- run-time environments for software application to execute,
- server infrastructure,
- value added intelligent software which helps developers to do
less coding and work efficiently,
The .Net Framework will enable
developers to develop applications for various devices and platforms like
windows application web applications windows services and web services.
The .NET Framework is designed to
fulfill the following objectives:
- A consistent object-oriented programming environment, where object
code can be stored and executed locally, executed locally but
Internet-distributed, or executed remotely.
- A code-execution environment that minimizes software deployment
and versioning conflicts.
- A code-execution environment that guarantees safe execution of
code, including code created by an unknown or semi-trusted third party.
- A code-execution environment that eliminates the performance
problems of scripted or interpreted environments.
- Developers can experience consistency across widely varying types
of applications, such as Windows-based applications and Web-based applications.
- Build all communication on industry standards to ensure that code
based on the .NET Framework can integrate with any other code.
the .NET Framework Architecture
The .NET Framework has two
components: the .NET Framework class library and the common language
The .NET Framework class
library facilitates types (CTS) that are common to all .NET languages.
The common language runtime
consists of (class loader) that load the IL code of a program into the runtime,
which compiles the IL code into native code, and executes and manage the code
to enforce security and type safety, and provide thread support.
.NET Framework Architecture
has languages at the top such as VB .NET C#, VJ#, VC++ .NET; developers can develop
(using any of above languages) applications such as Windows Forms, Web Form, Windows
Services and XML Web Services. Bottom two layers consist of .NET Framework
class library and Common Language Runtime. This we are going to understand
using this article.
Understanding the Role of .NET Framework
The .NET Framework has two main
components: the common language runtime (CLR) and the .NET Framework class
library. The common language runtime is the foundation of the .NET Framework.
CLR act as an agent that manages code at execution time, providing core
services such as memory management, thread management, and remoting, while also
enforcing strict type safety and facilitates with code accuracy that ensure
security and robustness. The concept of code management is a fundamental
principle of the CLR. Code that targets the CLR is known as managed code, while
code that does not target the CLR is known as unmanaged code.
The class library, is a integral component
of the .NET Framework, consists of object-oriented collection of reusable classes
(types) that we can use to develop applications ranging from traditional
command-line or any graphical user interface (GUI) applications such as Windows
Forms, ASP. NET Web Forms and Windows Services the newly invented XML Web
The European Computer
Manufacturers Association (ECMA) standard has defines the Common
Language Specification (CLS); this enforces that software development languages
should be interoperable between them. The code written in a CLS should be compliant
with the code written in another CLS-compliant language. Because the code supported
by CLS-compliant language should be compiled into an intermediate language (IL)
code. The CLR engine executes the IL code. This ensures interoperability
between CLS-compliant languages. Microsoft .NET Framework supports Languages
like Microsoft Visual Basic .NET, Microsoft Visual C#, Microsoft Visual C++
.NET, and Microsoft Visual J# .NET.
The language compilers generate
an Intermediate Language code, called Microsoft Intermediate Language (MSIL),
which makes programs written in the .NET languages interoperable across
The ECMA standard, Common
Language Infrastructure (CLI), defines the specifications for the
infrastructure that the IL code needs for execution. The CLI provides a common
type system (CTS) and services such as type safety, managed code execution and
side by side execution.
Figure 1. ECMA Standards
under Microsoft .NET Framework.
The .NET Framework provides the
infrastructure and services. The CLI specifications. These include:
Common language runtime.
- The CLR includes the CLI,
- The CLR also provides the execution environment for .NET
Common type system.
- Provides the data types, values, object
types. This helps developers to develop applications in different languages.
Where .NET languages share CTS mean all the types used in applications shares
the same types defined under CLI.
- .NET Framework performs operations on the values or objects for
which .NET Framework requires each value or object has a type and which
reference to the value or object type.
Managed code execution.
- .NET Framework manages the state of the object while executing
the .NET Applications.
- .NET Framework automatically allocates memory and provides
garbage collation mechanism to de-allocate memory.
- .NET Framework allows different version of the same application
to run on the same machine by using assemblies of different versions.
- Assemblies consist of IL Code and Metadata. Where metadata
determines the application dependencies. By this .NET Framework Runtime
executes multiple version of assembly and solves the major problem of legacy development
environment. That is the “DLL HELL”.
Figure 2 Side-by-side Execution.
.NET Framework CLR
The common language runtime
facilitates the followings:
Run-time environment and
- CLR Compiles application into the runtime, compile the IL code
into native code, execute the code
- Memory management,
- Type safety,
- Enforces Security,
- Exception Management.
- Thread support
- Debugging support
Architecture of .NET Framework CLR
- Class loader,
which loads classes into CLR.
- MSIL to native code compiles, this converts MSIL code into native
- Code manager, this manages the code during execution.
- Memory allocation and Garbage collector, this performs automatic
- Security engine, this enforces security restrictions as code
level security folder level and machine level security using tools provided by
Microsoft .NET and using .NET Framework setting under control panel.
- Type checker, which enforces strict type checking.
- Thread support, which provides multithreading support to
- Exception manager, which provides a mechanism to handle the
run-time exceptions handling.
- Debug engine, which allows developer to debug different types of
- COM marshaler, which allows .NET applications to exchange data
with COM applications.
- Base class library support, which provides the classes (types)
that the applications need at run time.
of the Common Language Runtime
The CLR has the following
- Manages memory,
- Allocation of Memory
- De-Allocation of Memory (garbage collation)
- Thread execution support,
- Code execution,
- Code safety verification,
- Code Security based on Trust
(granted permission to execute code. Code level, Folder level, Machine
These features are intrinsic to
the managed code that runs on the common language runtime.
To execute the program and gain
all the benefits of managed execution environment we write code in a language
which is supported by CLS that is .NET Framework. The language compiler
compiles the source code into the MSIL code which consists of CPU- independent
code and instructions which is platform independent. MSIL consists of the
- Instructions that enables to perform arithmetic and logical
- Access memory directly.
- Control the flow of execution,
- Handles exceptions,
MSIL code can be compiling into
CPU specific instructions before executing, for which the CLR requires
information about the code which is nothing but metadata. Metadata describes
the code and defines the types that the code contains as well referenced to
other types which the code uses at run time.
An assembly consists of portable
executable file. At the time of executing PE file the class loader loads the
MSIL code and the metadata form the portable executable file into the run time
Before the execution of PE file
it passes the code to the native code compiler for compilation, IL to native
code compilation is done by JIT compiler. For different CPU architecture and
compilers for the IL code in to the native instructions.
- Managed multithreading support and monitor the threads.
Application domain contains one or more threads to execute.
- Manages interoperability with unmanaged code, and COM marshaling
- A structured exception handling mechanism,
- The infrastructure and managed execution process, memory
management and garbage collection.
- Base class library support
supports all the base classes used for .net languages to support basic
- COM Marshaler
supports Marshaling of data between COM objects.
management supports handling Errors at runtime using try catch finally blocks.
engine enforces security rules at runtime.
- Type checker
checks for Type safe checks at runtime.
- Debug engine
supports debugging at runtime.
- Code manger
manages the Managed code at runtime.
- IL to native
compiler compiles the MSIL code to the Native code which is machine
collector supports the Memory management and supports Clearing unused memory at
- Class loader
lodes the classes at runtime
JIT compiler compiles is the
integral part of CLR. the MSIL code to Native code and executes the batch of
code Just in time which will be cached and next time when the code gets
executed from cache in stud of compiling again.
JIT Execution process.
CLR class loader lodes MSIL code
and metadata are loaded into memory; the code manager calls the entry point
method which is WinMain or DLLMain method. The JIT compiler compiles the method
to before its execution of the entry point method. The code manager places the
objects in memory and controls the execution of the code. The garbage collector
performs periodic checks on the managed heap to identify the objects which is
not in use for the application.
At the time of program execution
the type checker ensures that all objects and values, and the references of
objects and values has its valid type. The type checker also makes sure that
only valid operations are performed on the code other wise the exception will
be thrown. The code is controlled by CLR at run time. CLR enforces security in
- To control and access the system recourses like hard disk
- To control and access the network connections
- To control and access the other hard ware resources.
Managed code execution is known
as the process executed by the CLR which is as follows:
- CLR loads the MSIL & refers metadata,
- CLR executes the Native code,
- CLR provides automatic memory management.
- Managed execution also performs JIT compilations,
- Ensuring type safety,
- Enforcing security,
- Handling exceptions.
Managed code is self-explanatory code which gives information to
CLR for multiple runtime services in .NET Framework.
This information is stored in MSIL code in the form of metadata
inside the PE file. Mata data information will describe the types that the code
Managed data is allocated and released from memory automatically
by garbage collection. Managed data can be accessible form managed code but
managed code can be accessible from managed and unmanaged data.
Automatic memory management means
no need to write code to allocate memory when objects are created or to release
memory when objects are not required the application.
The process of automatic memory
management involves the following tasks:
When a process is initialized, the runtime reserves a contiguous
address space without allocating any storage space for it.
This reserved address space is called a managed heap. The managed
heap keeps a pointer at the location where the next object will be located.
When an application uses the new operator to create an object,
the new operator checks whether the memory required by the object is available
on the heap.
When the next object is created, the garbage collector allocates
memory to the object on the managed heap,
Allocating memory to the objects in a managed heap takes less
time than allocating unmanaged memory.
In unmanaged memory, the pointers to memory are maintained in
linked-list data structures. Therefore, allocating memory requires navigating
through the linked list, finding a large memory block to accommodate the
You can access objects in managed memory faster than objects in
unmanaged memory because in managed memory allocation, objects are created
contiguously in the managed address space.
The garbage collector periodically releases memory from the
objects that are no longer required by the application.
Every application has a set of roots. Roots point to the storage
location on the managed heap. Each root either refers to an object on the
managed heap or is set to null.
An application's roots consist of global and static object
pointers, local variables, and reference object parameters on a thread stack.
The JIT compiler and the run-time maintain the list of the
application roots. The garbage collector uses this list to create a graph of
objects on the managed heap that are reachable from the root list.
When the garbage collector starts running, it considers all the
objects on the managed heap as garbage.
The garbage collector navigates through the application root
list, it identifies the objects that have corresponding references in the
application root list and marks them as reachable.
The garbage collector also considers such objects as reachable
The garbage collector considers all unreachable objects on the managed
heap as garbage.
The garbage collector performs a collection process to free the
memory occupied by the garbage objects.
The garbage collector performs the memory copy function to
compress the objects in the managed heap.
The garbage collector updates the pointers in the application
root list so that the application roots correctly point to the objects to which
they were pointing earlier.
The garbage collector uses a highly optimized mechanism to
perform garbage collection. It divides the objects on the managed heap into
three generations: 0, 1, and 2. Generation 0 contains recently created objects.
The garbage collector first collects the unreachable objects in
generation 0. Next, the garbage collector compacts memory and promotes the
reachable objects to generation 1. The objects that survive the collection process are promoted to
The garbage collector searches for unreachable objects in
generations 1 and 2 only when the memory released by the collection process of
generation 0 objects is insufficient to create the new object.
The garbage collector manages memory for all managed objects
created by the application.
The garbage collection can explicitly release these system
resources by providing the cleanup code in the Dispose method of the object.
We need to explicitly call the Dispose method after you finish
working with the object.
The finalization process allows an object to perform cleanup
tasks automatically before garbage collection starts.
Finalize method ensures that even if the client does not call
the Dispose method explicitly, the resources used by the object are released
from memory when the object is garbage collected.
After the garbage collector identifies the object as garbage during
garbage collection, it calls the
Finalize method on the object before releasing
Finalizers are the methods that contain the cleanup code that is
executed before the object is garbage collected. The process of executing
cleanup code is called finalization. The
Finalize methods are
Dispose method of an object should release all its resources
in addition to the resources owned by its parent object by calling the
Dispose method of the parent object.
We can execute the
Dispose method in two ways.
- The user of the class can call
Dispose method on the object that is being disposed, or
Finalize method can call
Dispose method during the finalization process.
Assembly Linker - Al.exe Tool
Al tool can create an assembly or resource file with the
manifest in a separate file out of modules.
Syntax: al [source] [options]
This tool allows us to create multi-file assembly outside
.NET. A multi-file assembly is useful to combine modules developed under
different .NET languages into a single application.
IL Assembler - Ilasm.exe Tool
When we compile managed code, the code is converted into MSIL
code; this is CPU independent language which is converted to native code.
We can use Ilasm tool to generate a portable executable (PE) file
from the MSIL code. The resulting executable file is performance optimized,
where the Ilasm tool does not create intermediate object file
Syntax: Ilasm [source] filename [options]
We can specify multiple source files to produce a single PE file.
IL Disassembler - Ildasm.exe Tool
Ildasm tool is used to view PE file contains that is nothing but
the MSIL code as a parameter and creates the text file that consists of managed
Code Access Security Policy Tool - Caspol.exe Tool
Caspol is nothing but Code
Access Security Policy tool, which allows us to grant and modify permissions
granted to code groups at the user-policy, machine-policy, and enterprise-policy
Syntax: caspol [options]
.NET Framework Configuration Tool - Mscorcfg.msc
With this tool we can manage and configure assemblies in to the
global assembly cache. And also manage the code access security along with
This tool also creates code group policies at user level-
policies, machine level-policies, and enterprise level policies to assign and
remove the permissions on assemblies developed within .NET Framework.