Я смущен с MSIL и управляемым кодом, они такие же или разные? Я хочу сказать, что происходит, когда мы построили наш код на С#?
Какой из них правильный
C# Code → C# compiler → Managed Code → MSIL
или
C# Code → C# compiler → MSIL
Пожалуйста, предоставьте подлинную ссылку или ссылку в ответ на ваш ответ.
Вы путаете разные вещи. Управляемый код - это код, написанный на управляемом языке (С#, VB.NET, F # и многие другие), которые скомпилированы в CIL (Common Intermediate Language, ранее Microsoft Intermediate Language или MSIL) и выполнялись в управляемой среде CLR.
Неуправляемый код, с другой стороны, скомпилирован непосредственно в собственный код (также называемый сборкой), он не запускается на CLR.
Когда вы создаете свой код на С#, он скомпилирован в CIL. Вот почему вы можете использовать инструменты, такие как ildasm или Reflector, для проверки скомпилированного кода. Что именно происходит при выполнении кода CIL, зависит от обстоятельств. Это может быть
Как отмечено в комментариях, MSIL была переименована в CIL.
C# Code --> C# compiler --> CIL
потому что
CIL = Managed
Если в его контексте указывается
Native Code = Unmanaged
Обратите внимание, что Managed Code - это нечто совершенно иное, которое относится к исходному коду.
Если вы хотите его расширить, то исправленный полный процесс:
.NET Code --Compiler--> CIL (Managed) --JIT/NGEN--> Native Code (Unmanaged)
Литература:
Код, написанный для запуска исключительно под управлением CLR, называется управляемым кодом. (Источник). Итак,
Код С# → компилятор С# → CIL (ранее известный как MSIL)
является правильным.
При написании программ для 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 просто является форматом, который должен быть преобразован в код, чтобы исполняемая среда могла его выполнить.
Здесь я не буду вдаваться в подробности, потому что другие уже многое рассмотрели, но я хочу уточнить некоторые моменты, которые другие ответы на самом деле не объяснили хорошо или правильно. Это в значительной степени педантично, и для 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 - это две разные вещи, но они связаны между собой.