What are the basic components of .NET platform?
The basic components of .NET platform (framework) are:
| .Net Applications (Win Forms,Web Applications,Web Services) |
| Data(ADO.Net) and XML Library |
| FrameWork Class Library(FCL) (IO,Streams,Sockets,Security,Reflection,UI) |
| Common Language Runtime(CLR) (Debugger,Type Checker,JITer,GC) |
| Operating System (Windows,Linux,UNIX,Macintosh,etc.,) |
Common Language Runtime (CLR):
The
most important part of the .NET Framework is the .Net Common Language
Runtime (CLR) also called .Net Runtime in short. It is a framework layer
that resides above the Operating System and handles/manages the
execution of the .NET applications. Our .Net programs don't directly
communicate with the Operating System but through CLR.
MSIL (Microsoft Intermediate Language) Code:
When
we compile our .Net Program using any .Net compliant language like (C#,
VB.NET, C++.NET) it does not get converted into the executable binary
code but to an intermediate code, called MSIL or IL in short,
understandable by CLR. MSIL is an OS and H/w independent code. When the
program needs to be executed, this MSIL or intermediate code is
converted to binary executable code, called native code. The presence of
IL makes it possible the Cross Language Relationship as all the .Net
compliant languages produce the similar standard IL code.
Just In Time Compilers (JITers):
When
our IL compiled code needs to be executed, CLR invokes JIT compilers
which compile the IL code to native executable code (.exe or .dll) for
the specific machine and OS. JITers in many ways are different from
traditional compilers as they, as their name suggests, compile the IL to
native code only when desired e.g., when a function is called, IL of
function's body is converted to native code; just in time of need. So,
the part of code that is not used by particular run is not converted to
native code. If some IL code is converted to native code then the next
time when its needed to be used, the CLR uses the same copy without
re-compiling. So, if a program runs for sometime, then it won't have any
just in time performance penalty. As JITers are aware of processor and
OS exactly at runtime, they can optimize the code extremely efficiently
resulting in very robust applications. Also, since JITer knows the exact
current state of executable code, they can also optimize the code by
in-lining small function calls (like replacing body of small function
when its called in a loop, saving the function call time). Although,
Microsoft stated that C# and .Net are not competing with languages like
C++ in efficiency, speed of execution, JITers can make your code even
faster than C++ code in some cases when program is run over extended
period of time (like web-servers).
Framework Class Library (FCL):
.NET
Framework provides huge set of Framework (or Base) Class Library (FCL)
for common, usual tasks. FCL contains thousands of classes to provide
the access to Windows API and common functions like String Manipulation,
Common Data Structures, IO, Streams, Threads, Security, Network
Programming, Windows Programming, Web Programming, Data Access, etc. It
is simply the largest standard library ever shipped with any development
environment or programming language. The best part of this library is
they follow extremely efficient OO design (design patterns) making their
access and use very simple and predictable. You can use the classes in
FCL in your program just as you use any other class and can even apply
inheritance and polymorphism on these.
Common Language Specification (CLS):
Earlier
we used the term '.NET Compliant Language' and stated that all the .NET
compliant languages can make use of CLR and FCL. But what makes a
language '.NET compliant language'? The answer is Common Language
Specification (CLS). Microsoft has released a small set of specification
that each language should meet to qualify as a .NET Compliant Language.
As IL is a very rich language, it is not necessary for a language to
implement all the IL functionality, rather it meets the small subset of
it, CLS, to qualify as a .NET compliant language, which is the reason
why so many languages (procedural and OO) are now running under .Net
umbrella. CLS basically addresses to language design issues and lays
certain standards like there should be no global function declaration,
no pointers, no multiple inheritance and things like that. The important
point to note here is that if you keep your code within CLS boundary,
your code is guaranteed to be usable in any other .Net language.
Common Type System (CTS):
.NET
also defines a Common Type System (CTS). Like CLS, CTS is also a set of
standards. CTS defines the basic data types that IL understands. Each
.NET compliant language should map its data types to these standard data
types. This makes it possible for the 2 languages to communicate with
each other by passing/receiving parameters to/from each other. For
example, CTS defines a type Int32, an integral data type of 32 bits (4
bytes) which is mapped by C# through int and VB.Net through its Integer
data type.
Garbage Collector (GC):
CLR
also contains Garbage Collector (GC) which runs in a low-priority
thread and checks for un-referenced dynamically allocated memory space.
If it finds some data that is no more referenced by any
variable/reference, it re-claims it and returns the occupied memory back
to the Operating System; so that it can be used by other programs as
necessary. The presence of standard Garbage Collector frees the
programmer from keeping track of dangling data.
06:13
|
Category:
|
0
comments
Comments ( 0 )