Является ли MSIL таким же, как управляемый код в .NET?

Ответ 1

Вы путаете разные вещи. Управляемый код - это код, написанный на управляемом языке (С#, VB.NET, F # и многие другие), которые скомпилированы в CIL (Common Intermediate Language, ранее Microsoft Intermediate Language или MSIL) и выполнялись в управляемой среде CLR.

Неуправляемый код, с другой стороны, скомпилирован непосредственно в собственный код (также называемый сборкой), он не запускается на CLR.

Когда вы создаете свой код на С#, он скомпилирован в CIL. Вот почему вы можете использовать инструменты, такие как ildasm или Reflector, для проверки скомпилированного кода. Что именно происходит при выполнении кода CIL, зависит от обстоятельств. Это может быть

• скомпилирован в собственный код "как раз вовремя" с использованием JIT-компилятора (наиболее распространенная опция).
• выполняется с использованием предварительно скомпилированного собственного кода (вы можете использовать NGEN для его получения).
• напрямую интерпретируется; Я думаю, что какая-то версия .Net для Windows CE или аналогичная.

Ответ 2

Как отмечено в комментариях, MSIL была переименована в CIL.

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

потому что

CIL = Managed

Если в его контексте указывается

Native Code = Unmanaged

Обратите внимание, что Managed Code - это нечто совершенно иное, которое относится к исходному коду.

Если вы хотите его расширить, то исправленный полный процесс:

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

Литература:

• Представляем С# (что такое .NET Framework? → CIL и JIT → Первые две таблицы)

• JIT/NGEN (к модели затрат для управляемого кода → компилятор Just-in-Time → Целый)

Ответ 3

Код, написанный для запуска исключительно под управлением CLR, называется управляемым кодом. (Источник). Итак,

Код С# → компилятор С# → CIL (ранее известный как MSIL)

является правильным.

Ответ 4

При написании программ для Windows вы можете написать один из двух типов кода: управляемый и собственный. Собственный код скомпилирован непосредственно в исполняемый файл или .dll, тогда как управляемый код - это код, предназначенный для среды выполнения .NET(другими словами, его скомпилированная форма, называемая сборкой, представляет собой файл, содержащий инструкции CIL). Во время выполнения CIL преобразуется в машинный код компилятором JIT и выполняется. Разница между управляемым и native имеет отношение к тому, что предназначено для языка (и его компилятора). Внутренний код нацелен на сам компьютер, поскольку он скомпилирован в набор прямых машинных команд. С другой стороны, компиляторы С# компилируют ваш код в CIL, потому что компилятор языка С# нацелен на среду выполнения .NET. С# тогда можно было бы назвать "управляемым языком", а любой код, написанный в нем "управляемым кодом". Например:

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

Я думаю, что причина, по которой используется термин "управляемый", заключается в том, что инструкции, формирующие ваш код, в конечном итоге обрабатываются средой выполнения .NET, а не выполняются непосредственно процессором. Дополнительный шаг компиляции источника в CIL не является само по себе тем, что делает ваш код управляемым: скорее, тот факт, что ваша программа никогда не запускается непосредственно процессором. CIL - это то, что позволяет нескольким различным управляемым языкам ориентироваться на одну и ту же среду выполнения.

Я знаю, что это намного сложнее, чем просто сказать, что "управляемые языки компилируются в CIL", но это потому, что я действительно не думаю, что это полностью точное описание того, что делает код управляемым. Java-байт-код аналогичен CIL, но существуют фактические "Java-процессоры", которые могут изначально выполнять байт-код. Такой процессор также возможен для .NET CIL, что означает, что код, скомпилированный в CIL и работающий на такой машине, станет родным. Тот факт, что ваш код должен обрабатываться через CLR, - это то, что заставляет его управлять. CIL просто является форматом, который должен быть преобразован в код, чтобы исполняемая среда могла его выполнить.

Ответ 5

Здесь я не буду вдаваться в подробности, потому что другие уже многое рассмотрели, но я хочу уточнить некоторые моменты, которые другие ответы на самом деле не объяснили хорошо или правильно. Это в значительной степени педантично, и для 99,99999% случаев вы можете просто подумать о том, что "С# и CIL/MSIL - управляемый код", но есть некоторые тонкости этого.

Во-первых, CIL/MSIL известен как "промежуточный язык", что означает, что это компьютерный язык, который используется как промежуточный шаг между исходным кодом и конечным нативным машинным кодом. Однако это не обязательно. Я слышал об экспериментальных проектах, где они создали процессор, который выполняет CIL (или эквивалент java, называемый Java Byte Code) напрямую, без предварительного преобразования его в нативную форму (в основном, CIL является родной формой).

Управляемый код относится к коду, который "управляется" управляемой средой выполнения. Обычно это означает, что код содержит мусор и имеет некоторый уровень безопасности, который предотвращает такие переполнения буфера и другие проблемы, которые могут возникать в собственном коде. В .net это известно как Common Language Runtime (CLR)

В прежние времена это раньше называлось "виртуальной машиной" и почему среда Java называется JVM, хотя этот термин в настоящее время в значительной степени является неправильным. В настоящее время с компиляторами JIT (Just in time) нет фактической "виртуальной машины", но вместо этого это слой кода, который "обертывает" собственный скомпилированный код, чтобы гарантировать, что вы не нарушаете правила и очищаете после ваш код. Он также абстрагирует некоторые из специфических для платформы вещей, поэтому CIL не должен беспокоиться о них.

Таким образом, управляемый код относится к концепции кода, запущенного в управляемой среде выполнения. CIL считается управляемым кодом, когда он запущен во время выполнения, например среда выполнения .NET.

С# и VB.NET часто считаются "управляемыми языками", потому что они, как правило, скомпилированы в CIL и выполняются под управляемой средой выполнения. Однако это не обязательно должно быть так (хотя, если следовать букве спецификации, это, вероятно, должно быть так). Например, есть компиляторы, которые будут компилировать С# напрямую на собственный код без промежуточного уровня, и есть интерпретаторы времени выполнения для С#, которые вообще не компилируют код, а скорее "интерпретируют" его во время выполнения.

Итак, суть в том, что управляемый код и CIL - это две разные вещи, но они связаны между собой.