Ever wondered how .net runtime compilation
works? Let me try to explain it to the best of my understanding.
Lets take an
example
namespace TestConsole
{
class Program
{
static void Main(string[] args)
{
WriteHello();
}
public static void WriteHello()
{
Console.WriteLine("Hello");
}
}
}
At the runtime when CLR would see that there is a call to a
function WriteHello, it will try to find out all the types used inside the
function (here there is only one "Console"). It will then create an internal
datastructure and put all the available members of those types into there and
point them to an internal function "JITCompiler" something like as
following
Then CLR invokes JITCompiler for all
functions which have been used inside the current method for e.g. here we have
only one function WriteLine. JITCompiler goes to assembly for type Console and
looks into its metadata table. From there it will find the information about the
actual implementation (IL code) of the function WriteLine. It creates some
memory block and compiles that IL code to native memory using those blocks. it
comes back and changes the pointer (which was earlier pointing to itself) to
that memory block. refer following picture
*
please note that the function compiled should be void writeline(string s) (not
void writeline). I shall correct the image sometime later.After
JITCompiler job is done, it returns cursor back to Main function. Now CLR goes
in Main function once again and executes it. Not to mention, that next time
whenever JITCompiler will be invoked, it will work only for those functions who
are pointing to it that means runtime compilation will happen only once. Kindly
note that all native memory will be in persistance until your application is up,
whenever you make any changes to your .vb or .cs file, it causes your
application to be shutdown forcefully and start a new instance. As soon as your
application will go down, all compiled code (into native memory) will be flushed
and the whole process (runtime compilation) will start again for new instance of
application.
Since all the runtime compilation logic is inside function
JITCompiler, people don't mind calling the complete process itself is JIT
compilation.
Hope this will clear your at least one important low level
aspect of ASP.NET.