Understanding Dot Net Framework

Hi buddies,

Today I am going to explain about fundamentals of dot net as what I learnt. So if you know more than this article, I welcome your comments. Lets start,

courtesy: Shivprasad Koirala

The above picture clearly shows,

1. When we build our application using compiler( csc.exe for c#, vbc.exe vb.net etc) it returns the IL code.
2. IL code is nothing but CPU independent partially compiled code.
3. CLR is heart of Dot Net framework which pulls this IL code and give it JIT
4. JIT converts this IL code into executable instructions.

Why the language specific compilers such as csc.exe, vbc.exe etc provide half compiled code instead of full? because when we execute the exe this IL code converted as executable instructions by JIT (Just In Time compiler) in terms of optimized based on environment variables such as CPU capacity, RAM,OS,Memory etc...

When we learn about dot net framework we should know below listed things,

1. IL Code
2. Common Type System
3. Common Language Specification
4. Common Language Runtime
1. Garbage Collection
2. Code Access Security and Code Verification
1. Evidences
2. Permission Set
3. Code Group
3. Just In Time Compiler
1. Normal JIT
2. Ecno JIT
3. Pre JIT

IL Code

• Partially compiled CPU independent code
• Reason for Partially compiled already explained in above

Common Type System

• Generally Dot Net application is language independent.
• To achieve the cross platform support Dot net framework uses CTS
• So we can call a function in C# which is written in VB.net

Common Language Specification

• This subset of CTS
• Set rules or guidelines or specification needs to follow to achieve the cross platform support.
• To enable this guidelines to developer, add [assembly:CLSComplient(True)] in Assemblyinfo.cs

Garbage Collection

• It is a background process run by CLR
• It is clear the unused objects in dot net application and free up the memory
• It is having three generations gen0, gen1,gen2
• These Generations are increased the GC performance

Code Access Security & Code Verification

• It is security model, which grants or deny dot net assembly and exe depending on evidences.
• Evidences is nothing but where these code come from, for example has it come from internet or intranet etc
• Actually CAS is a three steps process
1. Before Dot Net assembly or exe executing, CAS starts to collecting evidence values
2. Based on evidence values permission are allocated via Permission Set
3. These Permission Set and evidences grouped by Code Group such as local,intranet,internet etc
• Microsoft has provide the visual studio command prompt utility "caspol.exe" to do this three steps process.

Just in Time Compiler (JIT)

• As I already told JIT will convert the IL code into optimized executable instructions based on environment variables
• Three kinds of JITs are there
1. Normal JIT -  Complie IL code and put it in memory cache. This can can be speed up the execution time. Generally this kind of JIT is used in desktop, laptop. 
2. Ecno JIT - Compile IL code and doesn't put it in memory cache. Means every time it's compile the IL code. Generally this kind of JIT is used in Windows mobile devices. 
3. Pre JIT - Compile full IL code into executable instructions. We can use it when we deploy our application in production server.
• Here we are not compile every time when execute the code. So it may be speed up our application performance.
• But this same advantage also becomes disadvantage when we execute the exe in another machine, beacuse the compilation done based on the source machine's environment values. So it may derives performance 
• We can compile the code through Pre JIT by using "NGEN.exe" command line utility
• We could not choose either Normal JIT or Ecno JIT as our wish. It is handled by CLR.

That's it for now. Hope you will get some useful info.