Before Microsoft intermediate language (MSIL) can be
executed, it must be converted by a .NET Framework
just-in-time (JIT) compiler to native code, which is
CPU-specific code that runs on the same computer
architecture as the JIT compiler. 
Rather than using time and memory to convert all the MSIL in
a portable executable (PE) file to native code, it converts
the MSIL as it is needed during execution and stores the
resulting native code so that it is accessible for
subsequent calls.
The runtime supplies another mode of compilation called
install-time code generation. The install-time code
generation mode converts MSIL to native code just as the
regular JIT compiler does, but it converts larger units of
code at a time, storing the resulting native code for use
when the assembly is subsequently loaded and executed.
As part of compiling MSIL to native code, code must pass a
verification process unless an administrator has established
a security policy that allows code to bypass verification.
Verification examines MSIL and metadata to find out whether
the code can be determined to be type safe, which means that
it is known to access only the memory locations it is
authorized to access. 

JIT is the just in time compiler,it is quite different with 
other compilers.It compiles the source code just in 
time,and it does not compiles hole code ,only the code is 
to be executed is compiled.there are three tipes of JIT.
pre jit,econo jit,normal jit.

JIT compiler (Just In Time Compiler) is the main part in the
CLR, which converts the MSIL code into the native code. It
compiles the program quickly in an efficient manner.

When compiling the source code to managed code, the 
compiler translates the source into Microsoft intermediate 
language 

(MSIL). This is a CPU-independent set of instructions that 
can efficiently be converted to native code. Microsoft 

intermediate language (MSIL) is a translation used as the 
output of a number of compilers. It is the input to a just-
in-time 

(JIT) compiler. The Common Language Runtime includes a JIT 
compiler for the conversion of MSIL to native code.

Before Microsoft Intermediate Language (MSIL) can be 
executed it, must be converted by the .NET Framework just-
in-time (JIT) 

compiler to native code. This is CPU-specific code that 
runs on the same computer architecture as the JIT compiler. 
Rather 

than using time and memory to convert all of the MSIL in a 
portable executable (PE) file to native code. It converts 
the MSIL 

as needed whilst executing, then caches the resulting 
native code so its accessible for any subsequent calls


JIT 
----

The Just-In-Time (JIT or JITter) compiler, converts the MSIL
(Microsoft Intermediate Language) code into the native code 
(CPU 

Specific code).

The .NET runtime/Common Language Runtime (CLR) ships three 
different classes of JITters. 

<li><b>Econo-JIT</b>: This compiler converts the MSIL code 
into native code without any optimizations. 

<li><b>Standard-JIT</b>: This compiler takes the MSIL code 
and optimizes it. So this compiler requires lot of 
resources like, 

time to compile, larger memory footprint, etc. 

<li><b>PreJIT</b>: This is based on the Main JIT and it 
works like the traditional compilers rather than Just-In-
Time 

compilers. This compiler is used at the time of 
installation.

JIT does not compiles hole code ,only the code is to be 
executed is compiled