Работа с неуправляемым кодом
Министерство образования Республики Беларусь
Учреждение образования «Белорусский государственный университет информатики и радиоэлектроники»
Факультет непрерывного и дистанционного обучения
Кафедра программного обеспечения информационных технологий
ПОЯСНИТЕЛЬНАЯ ЗАПИСКА
к контрольной работе № 1
по курсу «Операционные системы и системное программирование. Часть 3»
Студент: гр. 801021 Коноплёв А.П.
Руководитель: Прохорчик Р.В.
Минск 2011
Содержание
Работа с неуправляемым кодом………………………………………………….…3
1. Управляемый и неуправляемый код……………………………………………3
2.1. Службы COM Interoperability………………………………………………5
2.2. Обзор механизма преобразования………………………………………….6
2.3. Работа службы Platform Invoke. Запуск функций WinAPI……………….7
3. C++ .NET. Совмещение управляемого и неуправляемого кодов……………10
3.1. Управляемая библиотека…………………………………………………..13
3.2. Управляемая библиотека в управляемом коде……………………………14
3.3. Управляемая библиотека в неуправляемом коде…………………………15
3.4. Вызов неуправляемых функций из управляемого модуля………………15
3.5. Идентификация вызываемой функции……………………………………16
3.6. Создание класса для размещения библиотечной функции………………17
3.7. Прототипы в управляемом коде……………………………………………17
4. Небезопасный код………………………………………………………………19
Список использованных источников……………………………………….……..23
Управляемый и неуправляемый код
Управляемый код (англ. managed code) — термин, введённый Microsoft для обозначения кода программы, исполняемой виртуальной машиной .NET под управлением CLR.
С формальной точки зрения управляемым кодом является любой программный код, исполняемый в среде отладчика.
Неуправляемый код (англ. unmanaged code) — обычный машинный код, программный код, выполняющийся вне среды выполнения CLR.
Слово управляемый здесь относится к методу обмена информацией между программой и исполняющей средой. Оно означает, что в любой точке исполнения управляющая среда может приостановить исполнение и получить информацию, специфичную для текущего состояния.
Необходимая для этого информация представлена в управляемом коде на языке Intermediate Language и в связанных с этим кодом метаданных.
CIL (англ. Common Intermediate Language) — промежуточный язык, разработанный фирмой Microsoft для платформы .NET Framework.
CLR (англ. Common Language Runtime) — общая среда выполнения языков .NET.
Результатом проекта, написанного на C# и скомпилированного в Visual Studio 2008, является сборка (assembly), которая содержит IL-код (Intermediate Language код) проекта и манифест, полностью описывающий сборку. Сборка может быть создана на одном компьютере, на одной платформе, а выполняться на другом компьютере с другим типом процессора, с другой операционной системой. Для выполнения сборки необходимо и достаточно установки на целевом компьютере соответствующей версии Framework .Net, представляющего надстройку над операционной системой.
Когда мы говорим о сборках, язык программирования, на котором создавался исходный код, уже не имеет значения, его особенности никак не отражаются в сборке. Сборки, созданные на VB или C++ с управляемыми расширениями, неотличимы от сборок, которые созданы на C# или других языках, включенных в состав Visual Studio 2008 и использующих каркас Framework .Net при компиляции управляемого кода.С другой стороны, понятно, что в состав Visual Studio 2008 могут включаться языки, не применяющие Framework .Net, не создающие сборки с управляемым кодом, а использующие собственные библиотеки и собственные каркасы приложений (Framework Applications). В частности, на языке С++ в рамках Visual Studio 2008 можно писать проекты, работающие с библиотеками MFC и ATL, ориентированные исключительно на С++ и создающие в результате компиляции проекта обычные exe-файлы.
Сегодня на всех компьютерах, работающих под управлением любой из версий Windows, установлена соответствующая версия Framework .Net, так что на таких компьютерах могут выполняться и сборки, и обычные exe-файлы. Поскольку Framework .Net, так же как и C#, стандартизован и является свободно распространяемым программным продуктом, его можно встретить и на тех компьютерах, где нет Windows.
На рис. 1 показана схема функционирования компьютера, позволяющего выполнять как сборки — управляемый код, так и обычные exe-файлы — неуправляемый код.
Рис. 1. Управляемый и неуправляемый код
Следует заметить, что два типа программ, выполняемые по-разному, могут взаимодействовать друг с другом — из управляемого кода возможен вызов программ с неуправляемым кодом и наоборот. В проектах, написанных на C#, можно управлять офисными приложениями — документами Word и Excel. Офисные документы — это COM-объекты, принадлежащие миру неуправляемого кода, а проекты C# — это сборки, относящиеся к миру с управляемым кодом.
Примеры неуправляемого программного кода, вызываемого из управляемых C# приложений:
функции Win32 API;
функции DLL-библиотек;
компоненты COM;
интерфейсы Microsoft ActiveX.
Microsoft .NET Framework позволяет взаимодействовать с COM-компонентами, COM+-службами, внешними типами библиотек и разными службами операционной системы. Перехват исключений различается в управляемом и неуправляемом коде. Платформа .NET Framework предлагает две службы взаимодействия управляемого кода с неуправляемым — Platform Invoke и COM interoperability, которые используют реальные возможности проекта.
studfiles.net
1. Net Framework – единый каркас среды разработки. Исполнительная среда clr. Понятие и функции среды разработки. Управляемый и неуправляемый код. Сборщик мусора.
2. Управляемый и неуправляемый код. .Net Framework: особенности разработки приложений с использованием библиотеки .Net Framework. Необходимость установки нескольких версий библиотеки.
3. Единство каркаса Framework .Net. Встроенные примитивные и структурные типы.
• статический — FCL (Framework Class Library) — библиотеку классов каркаса;
• динамический — CLR (Common Language Runtime) — общеязыковую исполнительную среду.
Каркас стал единым для всех языков среды. Поэтому, на каком бы языке программирования не велась разработка, она использует классы одной и той же библиотеки. Многие классы библиотеки, составляющие общее ядро, используются всеми языками. Отсюда единство интерфейса приложения, на каком бы языке оно не разрабатывалось, единство работы с коллекциями и другими контейнерами данных, единство связывания с различными хранилищами данных и прочая универсальность.
Важной частью библиотеки FCL стали классы, задающие примитивные типы — те типы, которые считаются встроенными в язык программирования. Типы каркаса покрывают все множество встроенных типов, встречающихся в языках программирования. Типы языка программирования проецируются на соответствующие типы каркаса. Тип, называемый в языке Visual Basic — Integer, а в языке C# — int, проецируется на один и тот же тип каркаса System.Int32.
Частью библиотеки стали не только простые встроенные типы, но и структурные типы, задающие организацию данных — строки, массивы, перечисления, структуры (записи).
Компиляторы языков программирования, включенные в Visual Studio .Net, создают модули на промежуточном языке MSIL (Microsoft Intermediate Language), называемом далее просто — IL. Фактически компиляторы создают так называемый управляемый модуль — переносимый исполняемый файл (Portable Executable или PE-файл). Этот файл содержит код на IL и метаданные — всю необходимую информацию как для CLR, так и конечных пользователей, работающих с приложением. О метаданных — важной новинке Framework .Net — мы еще будем говорить неоднократно. В зависимости от выбранного типа проекта, PE-файл может иметь уточнения exe, dll, mod или mdl.
Заметьте, PE-файл, имеющий уточнение exe, хотя и является exe-файлом, но это не совсем обычный, исполняемый Windows, файл. При его запуске он распознается как специальный PE-файл и передается CLR для обработки. Исполнительная среда начинает работать с кодом, в котором специфика исходного языка программирования исчезла. Код на IL начинает выполняться под управлением CLR (по этой причине код называется управляемым). Исполнительную среду можно рассматривать как своеобразную виртуальную IL-машину. Эта машина транслирует «на лету» требуемые для исполнения участки кода в команды реального процессора, который в действительности и выполняет код.
Еще одной важной особенностью построения CLR является то, что исполнительная среда берет на себя часть функций, традиционно входящих в ведение разработчиков трансляторов, и облегчает тем самым их работу. Один из таких наиболее значимых компонентов CLR — сборщик мусора (Garbage Collector). Под сборкой мусора понимается освобождение памяти, занятой объектами, которые стали бесполезными и не используются в дальнейшей работе приложения.
studfiles.net
Управляемый и неуправляемый код — Студопедия.Нет
Как правило, при написании программы на C# формируется так называемый управляемый код. Как пояснялось выше, такой код выполняется под управлением среды CLR, и поэтому на него накладываются определенные ограничения, хотя это и дает ряд преимуществ. Ограничения накладываются и удовлетворятся довольно просто: ком пи-лятор должен сформировать файл MSIL, предназначенный для выполнения в среде CLR, используя при этом библиотеку классов .NET, — и то и другое обеспечивается средствами С#. Ко многим преимуществам управляемого кода относятся, в частности, современные способы управления памятью, возможность программирования на разных языках, повышение безопасности, поддержка управления версиями и четкая организация взаимодействия программных компонентов.
В отличие от управляемого кода, неуправляемый код не выполняется в среде CLR. Следовательно, до появления среды .NET Framework во всех программах для Windows применялся неуправляемый код. Впрочем, управляемый и неуправляемый коды могут взаимодействовать друг с другом, а значит, формирование управляемого кода в C# совсем не означает, что на его возможность* взаимодействия с уже существующими программами накладываются какие-то ограничения.
Общеязыковая спецификация
Несмотря на все преимущества, которые среда CLR дает управляемому коду, для максимального удобства его использования вместе с программами, написанными на других языках, он должен подчинятся общеязыковой спецификации (Common Language Specification — CLS), которая определяет ряд общих свойств для разных .NET-совместимых языков. Соответствие CLS особенно важно при создании программных компонентов, предназначенных для применения в других языках. В CLS в качестве подмножества входит общая система типов (Common Type System — CTS), в которой определяются правила, касающиеся типов данных. И разумеется, в C# поддерживается как CLS, так и CTS.
ГЛАВА 2 Краткий обзор элементов C#
Наибольшие трудности в изучении языка программирования вызывает то обстоятельство, что ни один из его элементов не существует обособленно. Напротив, все элементы языка действуют совместно. Такая взаимосвязанность затрудняет рассмотрение одного аспекта C# безотносительно к другому. Поэтому для преодоления данного затруднения в этой главе дается краткий обзор нескольких средств языка С#, включая общую форму программы на С#, ряд основных управляющих и прочих операторов. Вместо того чтобы углубляться в детали, в этой главе основное внимание уделяется лишь самым общим принципам написания любой программы на С#. А большинство вопросов, затрагиваемых по ходу изложения материала этой главы, более подробно рассматриваются в остальных главах части I.
Объектно-ориентированное программирование
Основным понятием C# является объектно-ориентированное программирование (ООП). Методика ООП неотделима от С#, и поэтому все программы на C# являются объектно-ориентированными хотя бы в самой малой степени. В связи с этим очень важно и полезно усвоить основополагающие принципы ООП, прежде чем приступать к написанию самой простой программы на С#.
ООП представляет собой эффективный подход к программированию. Методики программирования претерпели существенные изменения с момента изобретения
компьютера, постепенно приспосабливаясь, главным образом, к повышению сложности программ. Когда, например, появились первые ЭВМ, программирование заключалось в ручном переключении на разные двоичные машинные команды с переднего пульта управления ЭВМ. Такой подход был вполне оправданным, поскольку программы состояли всего из нескольких сотен команд. Дальнейшее усложнение программ привело к разработке языка ассемблера, который давал программистам возможность работать с более сложными программами, используя символическое представление отдельных машинных команд. Постоянное усложнение программ вызвало потребность в разработке и внедрении в практику программирования таких языков высокого уровня, как, например, FORTRAN и COBOL, которые предоставляли программистам больше средств для того, чтобы как-то справиться с постоянно растущей сложностью программ. Но как только возможности этих первых языков программирования были полностью исчерпаны, появились разработки языков структурного программирования, в том числе и С.
На каждом этапе развития программирования появлялись методы и инструментальные средства для «обуздания» растущей сложности программ. И на каждом таком этапе новый подход вбирал в себя все самое лучшее из предыдущих, знаменуя собой прогресс в программировании. Это же можно сказать и об ООП. До ООП многие проекты достигали (а иногда и превышали) предел, за которым структурный подход к программированию оказывался уже неработоспособным. Поэтому для преодоления трудностей, связанных с усложнением программ, и возникла потребность в ООП.
ООП вобрало в себя все самые лучшие идеи структурного программирования, объединив их с рядом новых понятий. В итоге появился новый и лучший способ организации программ. В самом общем виде программа может быть организована одним из двух способов: вокруг кода (т.е. того, что фактически происходит) или же вокруг данных (т.е. того, что подвергается воздействию). Программы, созданные только методами структурного программирования, как правило, организованы вокруг кода. Такой подход можно рассматривать «как код, воздействующий на данные».
Совсем иначе работают объектно-ориентированные программы. Они организованы вокруг данных, исходя из главного принципа: «данные управляют доступом к коду». В объектно-ориентированном языке программирования определяются данные и код, которому разрешается воздействовать на эти данные. Следовательно, тип данных точно определяет операции, которые могут быть выполнены над данными.
Для поддержки принципов ООП все объектно-ориентированные языки программирования, в том числе и С#, должны обладать тремя общими свойствами: инкапсуляцией, полиморфизмом и наследованием. Рассмотрим каждое из этих свойств в отдельности.
Инкапсуляция
Инкапсуляция — это механизм программирования, объединяющий вместе код и данные, которыми он манипулирует, исключая как вмешательство извне, так и неправильное использование данных. В объектно-ориентированном языке данные и код могут быть объединены в совершенно автономный черный ящик. Внутри такого ящика находятся все необходимые данные и код. Когда код и данные связываются вместе подобным образом, создается объект. Иными словами, объект — это элемент, поддерживающий инкапсуляцию.
В объекте код, данные или же и то и другое могут быть закрытыми или же открытыми. Закрытые данные или код известны и доступны только остальной части объекта. Это означает, что закрытые данные или код недоступны части программы, находящейся за пределами объекта. Если же данные или код оказываются открытыми, то они доступны другим частям программы, хотя и определены внутри объекта. Как правило, открытые части объекта служат для организации управляемого интерфейса с закрытыми частями.
Основной единицей инкапсуляции в C# является класс , который определяет форму объекта. Он описывает данные, а также код, который будет ими оперировать. В C# описание класса служит для построения объектов, которые являются экземплярами класса. Следовательно, класс, по существу, представляет собой ряд схематических описаний способа построения объекта.
Код и данные, составляющие вместе класс, называют членами. Данные, определяемые классом, называют полями, или переменными экземпляра. А код, оперирующий данными, содержится в функциях-членах, самым типичным представителем которых является метод. В C# метод служит в качестве аналога подпрограммы. (К числу других функций-членов относятся свойства, события и конструкторы.) Таким образом, методы класса содержат код, воздействующий на поля, определяемые этим классом.
Полиморфизм
Полиморфизм, что по-гречески означает «множество форм», — это свойство, позволяющее одному интерфейсу получать доступ к общему классу действий. Простым примером полиморфизма может служить руль автомашины, который выполняет одни и те же функции своеобразного интерфейса независимо от вида применяемого механизма управления автомашиной. Это означает, что руль действует одинаково независимо от вида рулевого управления: прямого действия, с усилением или реечной передачей. Следовательно, при вращении руля влево автомашина всегда поворачивает влево, какой бы вид управления в ней ни применялся. Главное преимущество единообразного интерфейса заключается в том, что, зная, как обращаться с рулем, вы сумеете водить автомашину любого типа.
Тот же самый принцип может быть применен и в программировании. Рассмотрим для примера стек, т.е. область памяти, функционирующую по принципу «последним пришел — первым обслужен». Допустим, что в программе требуются три разных типа стеков: один — для целых значений, другой — для значений с плавающей точкой, третий — для символьных значений. В данном примере алгоритм, реализующий все эти стеки, остается неизменным, несмотря на то, что в них сохраняются разнотипные данные. В языке, не являющемся объектно-ориентированным, для этой цели пришлось бы создать три разных набора стековых подпрограмм с разными именами. Но благодаря полиморфизму для реализации всех трех типов стеков в C# достаточно создать лишь один общий набор подпрограмм. Зная, как пользоваться одним стеком, вы сумеете воспользоваться и остальными.
В более общем смысле понятие полиморфизма нередко выражается следующим образом: «один интерфейс — множество методов». Это означает, что для группы взаимосвязанных действий можно разработать общий интерфейс. Полиморфизм помогает упростить программу, позволяя использовать один и тот же интерфейс для описания общего класса действий. Выбрать конкретное действие (т.е. метод) в каждом отдельном случае — это задача компилятора. Программисту не нужно делать это самому. Ему достаточно запомнить и правильно использовать общий интерфейс.
Наследование
Наследование представляет собой процесс, в ходе которого один объект приобретает свойства другого объекта. Это очень важный процесс, поскольку он обеспечивает принцип иерархической классификации. Если вдуматься, то большая часть знаний поддается систематизации благодаря иерархической классификации по нисходящей. Например, сорт яблок «Джонатан» входит в общую классификацию сортов яблок, которые, в свою очередь, относятся к классу фруктов, а те — к еще более крупному классу пищевых продуктов. Это означает, что класс пищевых продуктов обладает рядом свойств (съедобности, питательности и т.д.), которые по логике вещей распространяются и на его подкласс фруктов. Помимо этих свойств, класс фруктов обладает своими собственными свойствами (сочностью, сладостью и т.д.), которыми он отличается от других пищевых продуктов. У класса яблок имеются свои характерные особенности (растут на деревьях, не в тропиках и т.д.). Таким образом, сорт яблок «Джонатан» наследует свойства всех предшествующих классов, обладая в то же время свойствами, присущими только этому сорту яблок, например красной окраской кожицы с желтым бочком и характерным ароматом и вкусом.
Если не пользоваться иерархиями, то для каждого объекта пришлось бы явно определять все его свойства. А если воспользоваться наследованием, то достаточно определить лишь те свойства, которые делают объект особенным в его классе. Он может также наследовать общие свойства своего родителя. Следовательно, благодаря механизму наследования один объект становится отдельным экземпляром более общего класса.
Первая простая программа
А теперь самое время перейти к примеру конкретной программы на С#. Для начала скомпилируем и выполним короткую программу.
/*
Это простая программа на С#.
Назовем ее Example.cs.
*/
using System;
class Example {
studopedia.net
Службы Platform Invoke
Службы Platform Invoke позволяют управляемому коду запускать функции неуправляемого кода, которые находятся в файлах библиотек динамической компоновки (DLL). Эти службы предоставляют механизмы обнаружения и запуска неуправляемых функций и преобразование типов данных входящих и исходящих аргументов функции. Когда управляемый код запускает функцию неуправляемого кода, локализованную в DLL-файле, службы Platform Invoke находят этот DLL файл, загружают его в оперативную память и находят адрес функции в памяти. После этого службы передают входящие аргументы функции в стек, преобразовывают данные, которые необходимо перевести, эмулируют сборку мусора и передают управление по адресу неуправляемой функции в памяти.
Службы com Interoperability
Объектная модель COM (Common Object Model) компонентов имеет некоторые существенные отличия от объектной модели компонентов .NET Framework.
Управление жизненным циклом объектов. Клиенты СОМ-объектов сами управляют этим циклом, среда CLR платформы .NET берет эту задачу на себя.
Обращение к службам и объектам. Клиенты COM-объектов узнают о функциональности службы путем опроса ее интерфейса, клиенты .NET-объектов могут получить описание функциональности, используя пространство имен Reflection.
Среда CLR перемещает объекты в памяти для улучшения производительности, обновляя ссылки этих объектов. Клиенты COM имеют постоянную ссылку на ячейки памяти, не изменяющуюся в течение всей жизни объекта.
Для преодоления этих различий CLR предлагает классы-оболочки, которые позволяют управляемым и неуправляемым клиентам думать, что они работают с объектами той же среды, что и они сами. Когда управляемый клиент вызывает неуправляемый метод, CLR создает временную оболочку RCW (Runtime Callable Wrapper). RCW абстрагирует различия между управляемым и неуправляемым кодом. CLR также создает оболочку CCW (COM Callable Wrapper) для обращения процесса, которая позволяет COM-объектам запускать методы .NET-объектов.
Обзор механизма преобразования
Механизм преобразования определяет, какие типы данных должны быть переданы в метод и возвращены методом из управляемого в неуправляемый код и наоборот. Большинство типов данных имеют свои аналоги как в управляемом, так и в неуправляемом коде. Они не нуждаются в конвертировании при передаче из одной среды в другую. В пространстве имен System такими типами данных являются следующие:
System.Byte
System.SByte
System.Int16
System.UInt16
System.Int32
System.UInt32
System.Int64
System.IntPtr
System.UintPtr
Но есть и такие типы данных, которые имеют неоднозначное значение в управляемом и неуправляемом языках программирования. Эти типы нуждаются в конвертировании при переходе из управляемого в неуправляемый код и наоборот. Например, управляемая строка (string) имеет несколько значений в неуправляемом коде. В таблице 1 представлен список типов данных, которые нуждаются в конвертировании при переходе из одной среды в другую.
Таблица 1. Конвертирование типов данных
Тип данных | Тип при конвертировании |
System.Array | C-style или SAFEARRAY |
System.Boolean | 1-, 2- или 4-битовое значение со значением true как 1 или –1 |
System.Char | Символ кодировки ANSI или Unicode |
System.Class | Интерфейс class |
System.Object | Различные интерфейсы |
System.Mdarray | C-style или SAFEARRAY |
System.String | Строка с завершающим нулем (null-terminated string) или BSTR |
System.Valuetype | Структура |
System.Szarray | C-style или SAFEARRAY |
В большинстве случаев стандартные RCW и CCW, сгенерированные средой выполнения, предоставляют соответствующее преобразование типов между компонентами COM и .NET Framework. Используя атрибуты, вы можете настроить перевод из одного типа в другой.
studfiles.net
Что такое управляемый или неуправляемый код в программировании? — c#
Прежде всего, это понять, прежде чем .NET framework, Microsoft предоставили автономные продукты, такие как MFC (Visual C++), VB, FoxPro и т.д.
В 2002 году Microsoft объединила свои продукты и сделала платформу .NET. Теперь есть разница между тем, как был выполнен код до того, как код управляется и выполняется в среде .NET. Microsoft представила концепцию CLR с платформой .NET, которая компилирует код из любого поддерживаемого lanugague платформы .NET и предоставляет дополнительные функции, такие как memory mangement, garbage collection и т.д. Но такие функции CLR ранее не были доступны.
Итак, если вы создаете библиотеку/код в .NET framework (скомпилированный с помощью CLR), то это называется
Managed code. Вы можете использовать эту библиотеку далее в другом приложении/проекте .NET, и там тоже CLR будет понять, как он был скомпилирован раньше, и почему он остается вашим управлять кодом.
OTOH, если вы хотите использовать библиотеки, которые были написаны до .NET framework, тогда вы можете сделать с определенными ограничениями, но помните, поскольку в то время CLR не было, так что теперь CLR не будет понимать и компилировать этот код снова. И это будет называться unmanaged code. Обратите внимание, что библиотеки/сборки, созданные третьей стороной для предоставления определенных функций/инструментов, также могут считаться неуправляемым кодом, если это не совместимость с CLR.
В условиях неспециалистов Управление кодом — это то, что ваша среда CLR понимает и может скомпилировать ее самостоятельно для дальнейшего выполнения. В .NET framework (с любого языка, который работает на платформе .NET). Когда код переходит в CLR, тогда код снабжает некоторыми данными метаданных, поэтому CLR может предоставить вам определенные функции . Немногие из них Garbage collection, Performance improvements, cross-language integration, memory management и т.д.
OTOH, невыполненный код — это что-то конкретное для машины и готово к использованию, нет необходимости обрабатывать его дальше.
qaru.site
В чем разница в управляемом и неуправляемом коде, памяти и размере? — c#
Короткий ответ:
- Управляемый код — это код .NET(VB.NET, С# и т.д.), который вы пишете и компилируете в .NET CIL.
- Неуправляемый код — это код, который не находится под .NET, который компилируется для прямого машинного кода.
Длинный ответ:
Что такое управляемый код?
Управляемый код — это то, что создают компиляторы Visual Basic.NET и С#. Он компилируется на Intermediate Language (IL), а не на машинный код, который может запускаться непосредственно на вашем компьютере. CIL хранится в файле, называемом сборкой, вместе с метаданными, которые описывают классы, методы и атрибуты (например, требования безопасности) созданного вами кода. Эта сборка является единым магазином развертывания в мире .NET. Вы копируете его на другой сервер для развертывания сборки там, и часто это копирование является единственным шагом, необходимым для развертывания.
Управляемый код запускается в среде выполнения Common Language Runtime. Среда выполнения предлагает широкий спектр услуг для вашего текущего кода. В обычном ходе событий он сначала загружает и проверяет сборку, чтобы убедиться, что CIL в порядке. Затем, как раз вовремя, как называются методы, среда выполнения упорядочивает их для машинного кода, подходящего для машины, на которой выполняется сборка, и кэширует этот машинный код, который будет использоваться при следующем вызове метода. (Это называется Just In Time, или JIT-компиляция, или часто просто Jitting.)
По мере выполнения сборки среда выполнения продолжает предоставлять такие сервисы, как безопасность, управление памятью, потоки и т.п. Управлением управляет среда выполнения.
Visual Basic.NET и С# могут создавать только управляемый код. Если вы работаете с этими приложениями, вы делаете управляемый код. Visual С++.NET может создавать управляемый код, если хотите: при создании проекта выберите один из типов приложений, имя которых начинается с .Managed., Например,.Managed С++ application..
Что такое неуправляемый код?
Неуправляемый код — это то, что вы используете для создания Visual Studio.NET 2002. Visual Basic 6, Visual С++ 6, черт возьми, даже тот 15-летний компилятор C, который вы все еще можете использовать на своем жестком диске, вызвал неуправляемый код. Он был скомпилирован непосредственно с машинным кодом, который запускался на машине, на которой вы ее скомпилировали, и на других машинах, если они имеют один и тот же чип или почти одинаковый. Он не получал службы, такие как безопасность или управление памятью, из невидимой среды выполнения; он получил их из операционной системы. И что важно, он получил их из операционной системы явно, попросив их, обычно, вызывая API, предоставляемый в SDK Windows. Более поздние неуправляемые приложения получили службы операционной системы через вызовы COM.
В отличие от других языков Microsoft Visual Studio, Visual С++ может создавать неуправляемые приложения. Когда вы создаете проект и выбираете тип приложения, имя которого начинается с MFC, ATL или Win32, вы создаете неуправляемое приложение.
Это может привести к некоторой путанице: при создании приложения .Managed С++ продукт сборки представляет собой сборку CIL с расширением .exe. Когда вы создаете приложение MFC, продукт сборки является исполняемым файлом Windows собственного кода, а также расширением .exe. Внутренняя компоновка этих двух файлов совершенно различна. Вы можете использовать дизассемблер промежуточного языка, ildasm, чтобы заглянуть внутрь сборки и увидеть метаданные и CIL. Попробуйте указать ildasm на неуправляемом exe, и вам скажут, что он не имеет правильного заголовка CLR (Common Language Runtime) и не может быть дизассемблирован. Это же расширение, совершенно разные файлы.
Что относительно собственного кода?
Собственный код фразы используется в двух контекстах. Многие используют его как синоним неуправляемого кода: код, построенный со старым инструментом или преднамеренно выбранный в Visual С++, который не запускается во время выполнения, а вместо этого запускается изначально на машине. Это может быть полное приложение, или это может быть COM-компонент или DLL, вызываемый из управляемого кода с помощью COM Interop или PInvoke, двух мощных инструментов, которые позволяют использовать старый код при переходе в новый мир. Я предпочитаю говорить. Управляемый код. для этого значения, поскольку он подчеркивает, что код не получает службы среды выполнения. Например, защита кода доступа в управляемом коде предотвращает выполнение кода, загруженного с другого сервера, на выполнение определенных деструктивных действий. Если ваше приложение вызывает неуправляемый код, загруженный с другого сервера, вы не получите эту защиту.
Другое использование родного кода фразы — описание вывода компилятора JIT, машинного кода, который фактически выполняется во время выполнения. Это удалось, но это не CIL, это машинный код. В результате не просто предположите, что native = неуправляемый.
(Источник)
qaru.site
управляемому Что такое управляемый/неуправляемый код на C#?
Прежде всего, понимаем это, перед .NET framework Microsoft предоставляет автономные продукты, такие как MFC (Visual C++), VB, FoxPro и т. Д.
В 2002 году Microsoft объединила свои продукты и сделала платформу .NET. Теперь есть разница между тем, как был выполнен код до того, как код управляется и выполняется в среде .NET. Microsoft представила концепцию CLR с платформой .NET, которая компилирует код из любого поддерживаемого lanugague платформы .NET и предоставляет дополнительные функции, такие как управление memory mangement, garbage collection и т. Д. Но такие функции CLR ранее не были доступны.
Поэтому, если вы создаете библиотеку / код в .NET framework (скомпилированный с помощью CLR), то это называется
Managed code. Вы можете использовать эту библиотеку далее в другом приложении / проекте .NET, и там тоже CLR поймет, как она была скомпилирована ранее, и именно поэтому она остается вашим кодом управления.
OTOH, если вы хотите использовать библиотеки, которые были написаны до .NET framework, тогда вы можете сделать с определенными ограничениями, но помните, поскольку в то время CLR не было, так что теперь CLR не будет понимать и компилировать этот код снова , И это будет называться unmanaged code . Обратите внимание, что библиотеки / сборки, созданные третьей стороной для предоставления определенных функций / инструментов, также могут считаться неуправляемым кодом, если это не совместимость с CLR.
В условиях неспециалистов, код управления — это то, что ваша среда CLR понимает и может самостоятельно ее компилировать для дальнейшего выполнения. В .NET framework (с любого языка, который работает на платформе .NET). Когда код переходит в CLR, тогда код снабжает информацией о метаданных, так что CLR может предоставить вам функции, указанные here . Немногие из них — Garbage collection, Performance improvements, cross-language integration, memory management и т. Д.
OTOH, неизменный код — это нечто специфичное для машины и готовое к использованию, нет необходимости обрабатывать его дальше.
code.i-harness.com