MSIL与.NET中的托管代码相同吗？

Question

I am confused with MSIL and Managed Code are they same or different? I mean to say, what happens when we built our C# code?

Which one is right

C# Code → C# compiler → Managed Code → MSIL

or

C# Code → C# compiler → MSIL

Please provide authentic reference or link in support of your answer.

Answer 1

You're confusing different things. Managed code is code that's written in a managed language (C#, VB.NET, F# and many others) that's compiled into CIL (Common Intermediate Language, formerly Microsoft Intermediate Language or MSIL) and run in the managed environment of CLR.

Unmanaged code, on the other hand is compiled directly into native code (also called assembly), it does not run on CLR.

When you build your C# code, it's compiled into CIL. This is why you can use tools like ildasm or Reflector to inspect the compiled code. What exactly happens when you execute the CIL code depends on circumstances. It could be

1. compiled into native code “just in time” using the JIT compiler (the most common option).
2. executed using a pre-compiled native code (you can use NGEN to get that).
3. directly interpreted; I think some version of .Net for Windows CE, or similar does that.

Answer 2

As noted in the comments, MSIL has been renamed to CIL.

C# Code --> C# compiler --> CIL

because

CIL = Managed

When put in its context, there is also

Native Code = Unmanaged

Note that Managed Code is something completely different, which refers to the source code .

---

If you want to extend it, then the corrected full process is:

.NET Code --Compiler--> CIL (Managed) --JIT/NGEN--> Native Code (Unmanaged)

---

References:

1. Introducing C# (What is the .NET Framework? -> CIL and JIT -> First two sencences)

2. JIT / NGEN (Towards a Cost Model for Managed Code -> The Just-in-Time compiler -> The whole)

Answer 3

Code written to run exclusively under the control of the CLR is called managed code. ( Source ). So

C# Code → C# compiler → CIL (formerly known as MSIL)

is correct.

Answer 4

When you write programs for Windows, you can write one of two types of code: managed and native. Native code is compiled directly into a machine executible or .dll, whereas managed code is code that targets the .NET runtime (in other words its compiled form, termed an assembly, is a file containing CIL instructions). At runtime, the CIL is converted into machine code by the JIT compiler and executed. The difference between managed and native has to do with what the language (and its compiler) targets. Native code targets the machine itself because it's compiled into a set of direct machine instructions. On the other hand, C# compilers compile your code into CIL because the C# language compiler targets the .NET runtime. C# could then be said to be a "managed language", and any code written in it "managed code". For example:

C src  -> gcc.exe -> .exe containing a machine binary ->            processor
C# src -> csc.exe -> .exe assembly containing CIL     -> CLR/JIT -> processor

I think the reason the term "managed" is used is because the instructions forming your code are ultimately handled by the .NET runtime instead of being executed directly by the processor. The extra step of compiling source to CIL isn't in and of itself what makes your code managed: rather, the fact that your program never gets directly executed by the processor is. The CIL is just what allows multiple different managed languages to target the same runtime.

I know this is a lot wordier than just saying "managed languages compile into CIL", but that's because I don't really think that is a completely accurate description as to what makes the code managed. Java bytecode is analogous to CIL, but actual "Java processors" exist which can natively execute bytecode. Such a processor is also conceivable for .NET CIL, which means that code compiled into CIL and run on such a machine would then become native. The fact that your code must be handled through the CLR is what makes it managed. The CIL just happens to be the format that the code must be converted to becore the runtime can execute it.

Answer 5

I won't go into a lot of detail here, because others have already covered a lot of it, but I want to clarify some points that other answers have not really explained well or correctly. This is largely pedantic, and for 99.99999% of the cases you can just think of "C# and CIL/MSIL is managed code", but there are some subtleties to this.

First, CIL/MSIL is known as an "intermediate language", which means that it's a computer language that is used as an intermediate step between the source code and the final native machine code. However, this does not necessary have to be the case. I have heard about experimental projects where they have created a CPU that executes CIL (or the java equivalent called Java Byte Code) directly without first converting it to a native form (basically, the CIL is the native form).

Managed Code refers to code that is "managed" by a managed runtime of some sort. This typically means the code is garbage collected, and has some kind of security layer that prevents things like buffer overflows and other kinds of problems that can occur in native code. In .net this is known as the Common Language Runtime (CLR)

In the old days, this used to be known as a "virtual machine" and why the java environment is called a JVM, although that term is now largely a misnomer. Nowadays, with JIT (Just in time) compilers, there is no actual "virtual machine", but it's instead a layer of code that "wraps" the native compiled code to ensure you don't break the rules, and to clean up after your code. It also abstracts some of the platform specific things out so that the CIL doesn't have to worry about them.

So, Managed code refers to the concept of code running in a managed runtime. CIL is considered managed code when it is running in a runtime such as the .NET runtime environment.

C# and VB.NET are often considered "Managed Languages" because they are typically compiled to CIL and run under a managed runtime. However, this does not necessarily have to be the case (although if following the letter of the specification, it probably does have to be the case). For instance, there are compilers that will compile c# directly to native code without an intermediate level, and there are runtime interpreters for C# that do not compile the code at all, but rather "interpret" it at runtime.

So the gist is that Managed code and CIL are two different things, but they are related.