Compilation and Execution of a .NET
Application When you compile a .NET application, it is
not compiled to binary machine code; rather, it is converted to IL. This is the
form that your deployed application takes—one or more assemblies consisting of
executable files and DLL files in IL form. At least one of these assemblies
will contain an executable file that has been designated as the entry point for
the application.
When execution of
your program begins, the first assembly is loaded into memory. At this point,
the common language runtime examines the assembly manifest and determines the
requirements to run the program.
It examines security permissions requested by
the assembly and compares them with the system’s security policy. If the
system’s security policy does not allow the requested permissions, the
application will not run. If the application passes the system’s security
policy, the common language runtime executes the code. It creates a process
for the application to run in and begins application execution. When execution
starts, the first bit of code that needs to be executed is loaded into memory
and compiled into native binary code from IL by the common language runtime’s
Just-In-Time (JIT) compiler. Once compiled, the code is executed and stored in
memory as native code. Thus, each portion of code is compiled only once when an
application executes. Whenever program execution branches to code that has not
yet run, the JIT compiler compiles it ahead of execution and stores it in
memory as binary code. This way, application performance is maximized because
only the parts of a program that are executed are compiled.
No comments:
Post a Comment
Thank you for your valuable comment. Stay tuned for Updates.