So when CLR runtime load a .NET assembly, it compiles it into machine native code. This process is called JITing. NGen is also the process of compiling .NET assembly into native code. I don't understand what is the difference between two?
The difference is when they occur. The JIT compilation occurs while your program is running. NGen is a typically done at installation time of your program and happens before your program is run. One of the goals of NGen is to remove the JIT penalty from application start up.
JIT is only done per-method; it doesn't JIT everything... Only the bits you need. Of course this has a small but measurable hit the first time into a method (plus generics etc). NGEN does this work up-front, but must be done on the same platform/architecture etc - essentially that machine. This also means adding it to the GAC etc, which may need higher access.
In many cases, JIT is fine, especially if the app is open for a long time (web servers, for example).
One very major important difference that has yet to be mentioned is that the native cached images have 'shared code pages', which makes a huge difference in the memory footprint of applications running over Terminal Services or Citrix.
The critical thing to understand about NGEN is that whilst it compiles your code, it also marks the code pages as shareable, so that multiple instances of your application can share parts of the memory space used by the first instance. And that’s really useful if you’re running under Terminal Services.
This has very important implications for applications being used by multiple users on a single machine as they share memory across processes. This can lead to very strange, difficult to reproduce behaviour and resource management problems if the image caches are not well maintained.
From MSDN...
The Native Image Generator (Ngen.exe) is a tool that improves the performance of managed applications. Ngen.exe creates native images, which are files containing compiled processor-specific machine code, and installs them into the native image cache on the local computer. The runtime can use native images from the cache instead of using the just-in-time (JIT) compiler to compile the original assembly.
http://msdn.microsoft.com/en-us/library/6t9t5wcf(v=VS.100).aspx
Basically NGen allows you pre-JIT and cache the assembly on the local machine. This allows for a faster startup and sometimes execution.
Lots of details left out here, but:
Jit isn't quite that... Jit is Just-In-Time, meaning it doesn't get compiled to native code until the code, such as a method, is actually invoked. There are just stubs until then. This will remained cached so that subsequent calls to the method don't re-generate the native code.
NGen does the whole assembly at once. NGen does it all at once so that Jitting isn't required.
来源：https://stackoverflow.com/questions/5525082/jit-vs-ngen-what-is-the-difference