Quelle est la différence entre le code, la mémoire et la taille gérés et non gérés?
Après avoir vu et écouté beaucoup de choses sur le code géré et non géré, et sachant que la seule différence est que gérer concerne le CLR et que le non-géré se trouve en dehors du CLR, cela me rend vraiment curieux de le connaître en détail. De quoi s'agit-il, du code, de la mémoire et de la taille gérés et non gérés?
Comment le code que j'écris en C # peut-il être non géré alors qu'il s'agit d'un code C # et comment une mémoire de taille devient non gérée. Un exemple et un petit aperçu seraient utiles.
Réponse courte:
- Le code géré est le code .NET (VB.NET, C #, etc.) que vous écrivez et compilez en .NET CIL .
- Code non géré est un code ne se trouvant pas sous .NET qui est compilé en code machine direct.
Longue réponse:
Qu'est-ce que le code géré?
Le code géré est ce que les compilateurs Visual Basic .NET et C # créent. Il compile en langage intermédiaire (IL) et non en code machine pouvant être exécuté directement sur votre ordinateur. Le fichier CIL est conservé dans un fichier appelé un assemblage, avec des métadonnées décrivant les classes, les méthodes et les attributs (tels que les exigences de sécurité) du code que vous avez créé. This Assembly est l'unité de déploiement à guichet unique dans le monde .NET. Vous le copiez sur un autre serveur pour déployer l'assembly à cet emplacement, et souvent cette copie est la seule étape requise dans le déploiement.
Le code géré s'exécute dans le Common Language Runtime. Le moteur d'exécution offre une grande variété de services pour votre code d'exécution. Dans le cours normal des événements, il charge et vérifie d’abord l’Assemblée pour s’assurer que le CIL est bon. Ensuite, juste à temps, lorsque les méthodes sont appelées, le runtime organise leur compilation en un code machine adapté à la machine sur laquelle l'Assembly est en cours d'exécution, et met en cache ce code machine à utiliser lors du prochain appel de la méthode. (Ceci s'appelle Just In Time, ou JIT compiler, ou souvent simplement Jitting.)
Au fur et à mesure que l'Assembly s'exécute, le moteur d'exécution continue à fournir des services tels que la sécurité, la gestion de la mémoire, les threads, etc. L'application est gérée par le runtime.
Visual Basic .NET et C # peuvent uniquement produire du code managé. Si vous travaillez avec ces applications, vous créez du code géré. Visual C++ .NET peut produire du code managé si vous le souhaitez: Lorsque vous créez un projet, sélectionnez l'un des types d'application dont le nom commence par. Managed., Tel que. Managed C++ application ..
Qu'est-ce qu'un code non géré?
Le code non géré est ce que vous utilisiez avant la publication de Visual Studio .NET 2002. Visual Basic 6, Visual C++ 6, même si ce compilateur C vieux de 15 ans peut toujours avoir du mal à produire sur votre disque dur, tous ont généré du code non managé. Il a été compilé directement dans le code machine exécuté sur la machine sur laquelle vous l'avez compilé, ainsi que sur d'autres machines, à condition qu'elles aient la même puce ou presque. Il ne disposait pas de services tels que la sécurité ou la gestion de la mémoire à partir d’une exécution invisible; il les a obtenus du système d'exploitation. Et surtout, il les a explicitement obtenus du système d’exploitation, en les demandant, généralement en appelant une API fournie dans le SDK Windows. Les applications non gérées plus récentes ont obtenu des services du système d'exploitation via des appels COM.
Contrairement aux autres langages Microsoft de Visual Studio, Visual C++ peut créer des applications non gérées. Lorsque vous créez un projet et sélectionnez un type d'application dont le nom commence par MFC, ATL ou Win32, vous créez une application non gérée.
Cela peut entraîner une certaine confusion: lorsque vous créez une application .Managed C++., Le produit de construction est un Assembly of CIL avec une extension .exe. Lorsque vous créez une application MFC, le produit de construction est un fichier exécutable Windows de code natif, également doté d'une extension .exe. La disposition interne des deux fichiers est totalement différente. Vous pouvez utiliser le désassembleur de langage intermédiaire, ildasm, pour regarder à l'intérieur d'un assembly et voir les métadonnées et le CIL. Essayez de pointer ildasm sur un exe non géré et on vous dira qu’il n’a pas d’en-tête CLR (Common Language Runtime) valide et qu’il ne peut pas être désassemblé: même extension, fichiers complètement différents.
Qu'en est-il du code natif?
La phrase code natif est utilisée dans deux contextes. De nombreuses personnes l'utilisent comme synonyme de code non managé: code créé avec un outil plus ancien ou délibérément choisi dans Visual C++, qui ne s'exécute pas au moment de l'exécution, mais s'exécute de manière native sur la machine. Il peut s’agir d’une application complète, d’un composant COM ou de DLL appelée à partir de code géré à l'aide de COM Interop ou de PInvoke, deux outils puissants qui vous permettent d'utiliser votre ancien code lorsque vous passez à la nouveau monde. Je préfère dire. Code non géré. pour ce sens, car il souligne que le code ne reçoit pas les services du runtime. Par exemple, Code Access Security dans le code géré empêche le code chargé depuis un autre serveur d'effectuer certaines actions destructives. Si votre application appelle du code non géré chargé depuis un autre serveur, vous n'obtiendrez pas cette protection.
L’autre utilisation de l’expression code natif consiste à décrire la sortie du compilateur JIT, le code machine qui s’exécute réellement au moment de l’exécution. C'est géré, mais ce n'est pas CIL, c'est du code machine. Par conséquent, ne supposez pas que native = unmanaged.
( La source )
Cela pourrait être une très longue réponse, en parlant des nombreuses différences subtiles entre le code machine généré par un compilateur C et le code machine généré par le compilateur JIT à partir d'un programme géré. Assez long pour nécessiter un livre, mais de tels livres ont déjà été écrits. Jeffrey Richter, par exemple.
Je vais rester bref et vif, car toutes ces différences subtiles se résument à la règle unique:
Le code géré est un code qui alloue de la mémoire à partir du tas ramassé.
Le code managé s'exécute dans le domaine d'applications et le code non managé s'exécute sous le processus du système d'exploitation.
En règle générale, le code géré a une empreinte mémoire d'exécution supérieure à celle d'un code non écrit (non géré) bien écrit.
Les applications directement exécutées sous le système d'exploitation sont appelées
applications non gérées
tandis que les applications qui fonctionnent sous le framework .net sont appelées
applications gérées