Что такое неуправляемые ресурсы?

некоторые пользователи ранжируют открытые файлы, соединения с БД, выделенную память, растровые изображения, файловые потоки и т. д. среди управляемых ресурсов, другие среди неуправляемых. Так они управляемые или неуправляемые?

Я считаю, что ответ более сложный: когда вы открываете файл в .NET, вы, вероятно, используете какой-то встроенный класс .NET System.IO.File, FileStream или что-то еще. Поскольку это обычный класс .NET, он управляется. Но это обертка, которая внутри делает " грязную работу" (связывается с операционной системой с помощью Win32 DLL, вызывая функции низкого уровня или даже инструкции ассемблера), которые действительно открывают файл. И это то, о чем .NET не знает, неуправляемый. Но вы, возможно, можете открыть файл самостоятельно, используя инструкции ассемблера и обойти файловые функции .NET. Тогда дескриптор и открытый файл являются неуправляемыми ресурсами.

то же самое с DB: если вы используете какую-то сборку DB, у вас есть классы, такие как DbConnection и т. д., они, как известно, .NET и справился. Но они заворачивают "грязную работу", которая неуправляема (выделяют память на сервере, устанавливают с ней связь, т. е...). Если вы не используете этот класс-оболочку и не открываете какой-либо сетевой сокет самостоятельно и не связываетесь со своей собственной странной базой данных с помощью некоторых команд, она неуправляема.

эти классы-оболочки (File, DbConnection и т. д.) управляются, но они внутри используют неуправляемые ресурсы так же, как и вы, если вы не используете обертки и не делаете "грязную работу" самостоятельно. И поэтому эти обертки реализуют Шаблоны Dispose / Finalize. Это их обязанность позволить программисту освободить неуправляемые ресурсы, когда оболочка больше не нужна, и освободить их, когда оболочка собрана мусор. Оболочка будет правильно собрана сборщиком мусора, но неуправляемые ресурсы внутри будут собраны с помощью шаблона Dispose/Finalize.

Если вы не используете встроенные .NET или сторонние классы-оболочки и открываете файлы по некоторым инструкциям ассемблера и т. д. в вашем классе эти открытые файлы неуправляемы, и вы должны реализовать шаблон dispose/finalise. Если вы этого не сделаете, будет утечка памяти, навсегда заблокированный ресурс и т. д. даже если вы больше не используете его (файловая операция завершена) или даже после завершения работы приложения.

но ваша ответственность также при использовании этих обертки. Для тех, которые реализуют dispose/finalise (вы узнаете их, что они реализуют IDisposable), реализуйте также в вашем распоряжении/доработать шаблон и распоряжаться даже эти фантики или дать им сигнал, чтобы освободить их неуправляемые ресурсы. Если вы этого не сделаете, ресурсы будут выпущены через некоторое неопределенное время, но это чисто, чтобы немедленно освободить его (немедленно закройте файл и не оставляйте его открытым и заблокированным в течение случайных нескольких минут/часов). Поэтому в методе Dispose вашего класса вы вызываете методы Dispose всех ваших используемых оболочек.

неуправляемые ресурсы-это те, которые выполняются вне среды выполнения .NET (CLR)(aka non-.NET код.) Например, вызов библиотеки DLL в Win32 API или вызов a .dll написана на языке C++.

основное различие между управляемым и неуправляемым ресурсом заключается в том, что сборщик мусора знает обо всех управляемых ресурсах, в какой-то момент времени GC придет и очистит всю память и связанные с ней ресурсы с управляемым объектом. ГК не знает о неуправляемых ресурсах, таких как как файлы, поток и ручки, так что если вы не очистите их прямо в ваш код, то вы будете в конечном итоге с утечками памяти и заблокированных ресурсов.

украли из здесь, не стесняйтесь читать весь пост.

"неуправляемый ресурс" - это не вещь, а ответственность. Если объект владеет неуправляемым ресурсом, это означает, что (1) какой-либо объект вне его был обработан таким образом, что может вызвать проблемы, если он не очищен, и (2) объект имеет информацию, необходимую для выполнения такой очистки, и отвечает за это.

хотя многие типы неуправляемых ресурсов очень сильно связаны с различными типами объектов операционной системы (файлы, дескрипторы GDI, выделенные блоки памяти и т. д.) нет ни одного типа сущности, которая разделяется всеми из них, кроме ответственности за очистку. Как правило, если объект либо несет ответственность за выполнение очистки, он будет иметь метод Dispose, который инструктирует его выполнять всю очистку, за которую он отвечает.

в некоторых случаях объекты будут учитывать возможность того, что они могут быть оставлены без вызова Dispose first. ГК позволяет объектам запросите уведомление о том, что они были оставлены (путем вызова процедуры под названием Finalize), и объекты могут использовать это уведомление для выполнения очистки сами.

такие термины, как" управляемый ресурс "и" неуправляемый ресурс", к сожалению, используются разными людьми для обозначения разных вещей; откровенно говоря, более полезно думать в терминах объектов как либо не имеющих ответственности за очистку, имеющих ответственность за очистку, о которой будет заботиться только если Dispose называется, или имея ответственность за очистку, о которой следует позаботиться через Dispose, но о которой также можно позаботиться с помощью Finalize.

любой ресурс, для которого выделена память в управляемой куче .NET, является управляемым ресурсом. CLR полностью осознает этот вид памяти и сделает все, чтобы убедиться, что он не станет сиротой. Все остальное неуправляемо. Например, взаимодействие с COM может создавать объекты в пространстве памяти proces, но CLR не будет заботиться об этом. В этом случае управляемый объект, который выполняет вызовы через управляемую границу, должен нести ответственность за все, что находится за ее пределами.

давайте сначала поймем, как VB6 или C++ программы (не Dotnet приложения) используются для выполнения. Мы знаем, что компьютеры понимают только машинный код. Машинный код также называется собственным или двоичным кодом. Таким образом, когда мы выполняем программу VB6 или C++, соответствующий компилятор языка компилирует исходный код соответствующего языка в собственный код, который затем может быть понят базовой операционной системой и аппаратным обеспечением.

собственный код (неуправляемый код) является специфичным (родной) для операционной системы, в которой он создан. Если вы возьмете этот скомпилированный машинный код и попытаетесь запустить его в другой операционной системе, это не удастся. Таким образом, проблема с этим стилем выполнения программы заключается в том, что он не переносится с одной платформы на другую платформу.

Давайте теперь разберемся, как выполняется программа .Net. С помощью dotnet мы можем создавать различные типы приложений. Некоторые из распространенных типов приложений .NET включают веб, Windows, консоль и мобильный Приложения. Независимо от типа приложения, при выполнении любого приложения .NET происходит следующее

1. приложение .NET компилируется в промежуточный язык (IL). IL также называют общим промежуточным языком (CIL) и промежуточным языком Microsoft (MSIL). Оба .Чистый и номера .Net приложений создания сборки. Сборки имеют расширение .DLL или .ИСПОЛНЯЕМЫЙ. Например, если вы компилируете приложение windows или консоль, вы получаете .EXE, где, как и при компиляции веб-проекта или проекта библиотеки классов, мы получаем .файл DLL. Разница между сборкой .NET и не .NET заключается в том, что сборка DOTNET находится в формате промежуточного языка, где сборка as NON DOTNET находится в формате собственного кода.

2. не DOTNET приложения могут работать непосредственно поверх операционной системы, где как DOTNET приложения работают поверх виртуальной среды, называемой как среда CLR (Common Language Runtime). Среда CLR содержит компонент с именем Just In-Time Compiler (JIT), который преобразует промежуточный язык в собственный код, который может понять базовая операционная система.

Итак, в .NET выполнение приложения состоит из 2 шагов 1. Компилятор языка, компилирует исходный код на промежуточный язык (IL) 2. JIT-компилятор в среде CLR преобразует IL в собственный код, который затем может быть запущен в базовой операционной системе.

Так как сборка .NET находится на языке Intermedaite форматирование, а не машинный код, сборки .NET переносятся на любую платформу, если целевая платформа имеет среду CLR (Common Language Runtime). Среда CLR целевой платформы преобразует язык Intermedaite в собственный код, который может понять базовая операционная система. Промежуточный язык также называется управляемым кодом. Это связано с тем, что среда CLR управляет кодом, который выполняется внутри нее. Например, в программе VB6 разработчик отвечает за выделение памяти, потребляемой объектом. Если программист забывает о выделении памяти, мы можем столкнуться с трудными для обнаружения исключениями из памяти. С другой стороны, программисту .NET не нужно беспокоиться о выделении памяти, потребляемой объектом. Автоматическое управление памятью, также известный как коллекция grabage осуществляется в среде CLR. Помимо сборки мусора, есть несколько других преимуществ, предоставляемых средой CLR, которые мы обсудим в следующем сеансе. Поскольку среда CLR управляет и выполняет промежуточный язык, она (IL также называется управляемым кодом.

.NET поддерживает различные языки программирования, такие как C#, VB, J# и C++. C#, VB и J# могут генерировать только управляемый код (IL), где как C++ может генерировать как управляемый код (IL), так и неуправляемый код (собственный код).

нативный код нигде не хранится постоянно, после закрытия программы нативный код выбрасывается awaya. Когда мы снова запускаем программу, машинный код генерируется снова.

программа .NET аналогична для выполнения программы Java. В java у нас есть байтовые коды и JVM (Java Virtual Machine), где, как и в .NET, мы промежуточный язык и CLR (Common Language Runtime)

Это предусмотрено по этой ссылке - он великий наставник. http://csharp-video-tutorials.blogspot.in/2012/07/net-program-execution-part-1.html