.NET Framework (.NET)
Definition - What does .NET Framework (.NET) mean?
The .NET
framework is a software development framework from Microsoft. It
provides a controlled programming environment where software can be
developed, installed and executed on Windows-based operating systems.
The principal design features are:
The principal design features are:
- Interoperability: This allows for .NET-developed programs to access functionalities in programs developed outside .NET.
- Common Runtime Engine: Also known as the common language runtime, this allows programs developed in .NET to exhibit common behaviors in memory usage, exception handling and security.
- Language Independence: Common language infrastructure specifications (CLI) allow for the exchange of data types between two programs developed in different languages.
- Base Class Library: A library of code for most common functions--used by programmers to avoid repetitive rewriting of code.
- Ease of Deployment: There are tools to ensure the ease of installing programs without interfering with previously installed applications.
- Security: Programs developed in .NET are based on a common security model.
How to Microsoft .Net Framework
Microsoft .Net Languages Source Code are compiled
into Microsoft Intermediate Language (MSIL) . MSIL we can call it as
Intermediate Language (IL) or Common Intermediate Language (CIL).
Microsoft Intermediate Language (MSIL) is a CPU independent set of
instructions that can be converted to the native code. Metadata also
created in the course of compile time with Microsoft Intermediate
Language (MSIL) and stored it with the compiled code . Metadata is
completely self-describing . Metadata is stored in a file called
Manifest, and it contains information about the members, types,
references and all the other data that the Common Language Runtime (CLR)
needs for execution .
The Common Language
Runtime (CLR) uses metadata to locate and load classes, generate native
code, provide security, and execute Managed Code. Both Microsoft
Intermediate Language (MSIL) and Metadata assembled together is known as
Portable Executable (PE) file. Portable Executable (PE) is supposed to
be portable across all 32-bit operating systems by Microsoft .Net
Framework.
During the runtime the Common Language Runtime
(CLR)'s Just In Time (JIT) compiler converts the Microsoft Intermediate
Language (MSIL) code into native code to the Operating System. The
native code is Operating System independent and this code is known as
Managed Code , that is, the language's functionality is managed by the
.NET Framework . The Common Language Runtime (CLR) provides various Just
In Time (JIT) compilers, and each works on a different architecture
depends on Operating Systems, that means the same Microsoft Intermediate Language
(MSIL) can be executed on different Operating Systems. From the
following section you can see how Common Language Runtime (CLR)
functions .
Microsoft Intermediate Language - MSIL
MSIL stands for Microsoft Intermediate Language. We
can call it as Intermediate Language (IL) or Common Intermediate
Language (CIL). During the compile time , the compiler convert the
source code into Microsoft Intermediate Language (MSIL) .Microsoft
Intermediate Language (MSIL) is a CPU-independent set of instructions
that can be efficiently converted to the native code. During the runtime
the Common Language Runtime (CLR)'s Just In Time (JIT) compiler converts the Microsoft Intermediate Language (MSIL) code into native code to the Operating System.
When a compiler produces Microsoft Intermediate Language (MSIL), it also produces Metadata.
The Microsoft Intermediate Language (MSIL) and Metadata are contained
in a portable executable (PE) file . Microsoft Intermediate Language
(MSIL) includes instructions for loading, storing, initializing, and
calling methods on objects, as well as instructions for arithmetic and
logical operations, control flow, direct memory access, exception
handling, and other operations.
Common Language Runtime
The Common Language Runtime (CLR) is an Execution
Environment . It works as a layer between Operating Systems and the
applications written in .Net languages that conforms to the Common
Language Specification (CLS). The main function of Common Language
Runtime (CLR) is to convert the Managed Code into native code and then
execute the Program. The Managed Code compiled only when it needed, that
is it converts the appropriate instructions when each function is
called . The Common Language Runtime (CLR) 's Just In Time (JIT) compilation converts Intermediate Language (MSIL) to native code on demand at application run time.
During the execution of the program ,the Common
Language Runtime (CLR) manages memory, Thread execution, Garbage
Collection (GC) , Exception
Handling, Common Type System (CTS), code safety verifications, and
other system services. The CLR ( Common Language Runtime ) defines the
Common Type System (CTS), which is a standard type system used by all
.Net languages . That means all .NET programming languages uses the same
representation for common Data Types
, so Common Language Runtime (CLR) is a language-independent runtime
environment . The Common Language Runtime (CLR) environment is also
referred to as a managed environment, because during the execution of a
program it also controls the interaction with the Operating System. In
the coming section you can see what are the main functions of Common Language Runtime (CLR).
Just In Time Compiler - JIT
The .Net languages , which is conforms to the Common Language Specification
(CLS), uses its corresponding runtime to run the application on
different Operating Systems . During the code execution time, the Managed Code
compiled only when it is needed, that is it converts the appropriate
instructions to the native code for execution just before when each
function is called. This process is called Just In Time (JIT)
compilation, also known as Dynamic Translation . With the help of Just
In Time Compiler (JIT) the Common Language Runtime (CLR) doing these tasks.
The Common Language Runtime (CLR) provides various
Just In Time compilers (JIT) and each works on a different architecture
depending on Operating System. That is why the same Microsoft Intermediate Language
(MSIL) can be executed on different Operating Systems without rewrite
the source code. Just In Time (JIT) compilation preserves memory and
save time during application initialization. Just In Time (JIT)
compilation is used to run at high speed, after an initial phase of
slow interpretation. Just In Time Compiler (JIT) code generally offers
far better performance than interpreters.
Common Language Specification - CLS
Common Language Specification (CLS) is a set of basic
language features that .Net Languages needed to develop Applications
and Services , which are compatible with the .Net Framework.
When there is a situation to communicate Objects written in different
.Net Complaint languages , those objects must expose the features that
are common to all the languages . Common Language Specification (CLS)
ensures complete interoperability among applications, regardless of the
language used to create the application.
Common Language Specification (CLS) defines a subset
of Common Type System (CTS) . Common Type System (CTS) describes a set
of types that can use different .Net languages have in common , which
ensure that objects written in different languages can interact with
each other. Most of the members defined by types in the .NET Framework
Class Library (FCL) are Common Language Specification (CLS) compliant
Types. Moreover Common Language Specification (CLS) standardized by
ECMA .
Common Type System - CTS
Common Type System (CTS) describes a set of types
that can be used in different .Net languages in common . That is , the
Common Type System (CTS) ensure that objects written in different .Net
languages can interact with each other. For Communicating between
programs written in any .NET complaint language, the types have to be
compatible on the basic level .
These types can be Value Types or Reference Types .
The Value Types are passed by values and stored in the stack. The
Reference Types are passed by references and stored in the heap. Common
Type System (CTS) provides base set of Data Types which is responsible for cross language integration. The Common Language Runtime
(CLR) can load and execute the source code written in any .Net
language, only if the type is described in the Common Type System (CTS)
.Most of the members defined by types in the .NET Framework Class Library (FCL) are Common Language Specification (CLS) compliant Types.
Portable Executable (PE) File Format
The Portable Executable (PE) format is a file format
for executables, object code, and DLLs, used in 32-bit and 64-bit
versions of Windows operating systems.
The PE file format was defined to provide the best
way for the Windows Operating System to execute code and also to store
the essential data which is needed to run a program. Portable Executable
File Format is derived from the Microsoft Common Object File Format
(COFF).