Qu'est-ce qu'un code managé ou non managé en programmation?

J'utilise une commande spécifique dans mon code C #, qui fonctionne bien. Cependant, on dit qu'il se comporte mal dans le code "non managé".

Qu'est-ce qu'un code géré ou non géré?

Voici un texte de MSDN sur le code non géré .

Certains codes de bibliothèque doivent appeler du code non managé (par exemple, des API de code natif, telles que Win32). Étant donné que cela signifie sortir du périmètre de sécurité pour le code managé, la prudence est de mise.

Voici une autre explication complémentaire sur le code managé:

• Code exécuté par le CLR.
• Le code qui cible le Common Language Runtime, le fondement du .NET Framework, est appelé code managé.
• Le code géré fournit les métadonnées nécessaires au CLR pour fournir des services tels que la gestion de la mémoire, l'intégration multilingue, la sécurité d'accès au code et le contrôle automatique de la durée de vie des objets. Tout le code basé sur IL s'exécute en tant que code managé.
• Code qui s'exécute dans l'environnement d'exécution CLI.

Pour votre problème:

Je pense que c'est parce que NUnit exécute votre code pour UnitTesting et peut en avoir une partie qui n'est pas gérée. Mais je n'en suis pas sûr, alors ne le prenez pas pour de l'or. Je suis sûr que quelqu'un pourra vous donner plus d'informations à ce sujet. J'espère que ça aide!

C'est un bon article sur le sujet.

Résumer,

1. Le code géré n'est pas compilé en code machine mais en un langage intermédiaire qui est interprété et exécuté par un service sur une machine et fonctionne donc dans un cadre sécurisé (espérons-le!) Qui gère les choses dangereuses comme la mémoire et les threads pour vous. Dans l'usage moderne, cela signifie souvent .NET mais ce n'est pas obligatoire.

Un programme d'application qui est exécuté dans un moteur d'exécution installé sur la même machine. L'application ne peut pas fonctionner sans elle. L'environnement d'exécution fournit la bibliothèque générale de routines logicielles que le programme utilise et effectue généralement la gestion de la mémoire. Il peut également fournir une conversion juste à temps (JIT) du code source en code exécutable ou d'un langage intermédiaire en code exécutable. Java, Visual Basic et CLR (Common Language Runtime) de .NET sont des exemples de moteurs d'exécution. ( Lire la suite )

2. Le code non managé est compilé en code machine et donc exécuté directement par le système d'exploitation. Il a donc la capacité de faire des choses dommageables / puissantes que le code managé n'a pas. C'est ainsi que tout fonctionnait auparavant, il est donc généralement associé à de vieux éléments comme .dlls.

Un programme exécutable qui s'exécute par lui-même. Lancé à partir du système d'exploitation, le programme fait appel et utilise les routines logicielles du système d'exploitation, mais ne nécessite pas l'utilisation d'un autre système logiciel. Les programmes en langage assembleur qui ont été assemblés en langage machine et les programmes C / C ++ compilés en langage machine pour une plate-forme particulière sont des exemples de code non managé. ( En savoir plus )

3. Le code natif est souvent synonyme de non géré, mais n'est pas identique.

Lorsque vous pensez à un code non géré , pensez à un code spécifique à la machine. Comme le langage d'assemblage x86. Le code non géré (natif) est compilé et lié pour s'exécuter directement sur le processeur pour lequel il a été conçu, à l'exclusion de tout le système d'exploitation pour le moment. Ce n'est pas portable, mais c'est rapide. Code très simple et dépouillé.

Le code géré est tout, de Java à l'ancien interpréteur BASIC, ou tout ce qui fonctionne sous .NET. Le code géré est généralement compilé en un P-Code de niveau intermédiaire ou un ensemble d'instructions de code d'octet. Ce ne sont pas des instructions spécifiques à la machine, bien qu'elles ressemblent au langage d'assemblage. Le code géré isole le programme de la machine sur laquelle il s'exécute et crée une limite sécurisée dans laquelle toute la mémoire est allouée indirectement, et de manière générale, vous n'avez pas d'accès direct aux ressources de la machine comme les ports, l'espace d'adressage mémoire, la pile, etc. L'idée est de fonctionner dans un environnement plus sécurisé.

Pour convertir une variable gérée, par exemple, en une variable non gérée, vous devez accéder à l'objet lui-même. Il est probablement emballé ou emballé dans un emballage supplémentaire. Les variables non gérées (comme un 'int', par exemple) - sur une machine 32 bits - prennent exactement 4 octets. Il n'y a pas de frais généraux ou d'emballage supplémentaire. Le processus qui consiste à passer du code géré au code non géré - et inversement - est appelé « marshaling ». Il permet à vos programmes de franchir la frontière.

En aussi peu de mots que possible:

• code managé = programmes .NET
• code non managé = programmes "normaux"

Le code géré est ce que les compilateurs C # .Net, VB.Net, F # .Net, etc. créent. Il fonctionne sur le CLR, qui offre entre autres des services tels que le ramasse-miettes et la vérification des références, et bien plus encore. Alors pensez-y comme, mon code est géré par le CLR.

D'autre part, le code non managé se compile directement en code machine. Ce n'est pas géré par CLR.

Fondamentalement, le code non managé est du code qui ne s'exécute pas sous .NET CLR (c'est-à-dire pas VB.NET, C #, etc.). Je suppose que NUnit a un runner / wrapper qui n'est pas du code .NET (aka C ++).

Code géré:
code qui s'exécute dans le cadre d'un "contrat de coopération" avec le Common Language Runtime. Le code géré doit fournir les métadonnées nécessaires à l'exécution pour fournir des services tels que la gestion de la mémoire, l'intégration multilingue, la sécurité d'accès au code et le contrôle automatique de la durée de vie des objets. Tout le code basé sur le langage intermédiaire Microsoft (MSIL) s'exécute en tant que code managé.

Code non géré:
code créé sans tenir compte des conventions et des exigences du Common Language Runtime. Le code non managé s'exécute dans l'environnement d'exécution du langage commun avec des services minimaux (par exemple, pas de garbage collection, débogage limité, etc.).

Référence: http://www.dotnetspider.com/forum/11612-difference-between-managed-and-unmanaged-code.aspx

NUnit charge les tests unitaires dans un AppDomain séparé, et je suppose que le point d'entrée n'est pas appelé (probablement pas nécessaire), donc l'assembly d'entrée est nul.

Le code géré s'exécute dans l'environnement de CLR, c'est-à-dire .NET runtime.En bref, tous les IL sont du code managé.Mais si vous utilisez un exemple de logiciel tiers, un composant VB6 ou VC ++, il s'agit de code non géré car le runtime .NET (CLR) n'a pas de contrôle sur l'exécution du code source du langage.

Code managé: - Code dont la forme MSIL (langage intermédiaire) est développée après la compilation du compilateur de langage et directement exécutée par le CLRcode managé appelé. Par exemple: - Tous les 61 codes de langue pris en charge par le framework .net

Code non managé: - le code qui a été développé auparavant .netpour lequel le formulaire MSIL n'est pas disponible et il est exécuté CLRdirectement CLRredirigera plutôt vers le système d'exploitation, ce qu'on appelle du code non managé.

par exemple: -COM, API Win32

• Code managé : code écrit en langage .NET comme C #, VB.NET.
• Code non géré : code non écrit en langage .NET et MSIL ne comprend pas ce que c'est et ne peut pas s'exécuter sous CLR; comme les contrôles tiers que nous avons utilisés dans nos applications .NET qui ne sont pas créés dans les langages .NET.

Tout d' abord comprendre, avant .NET framework, Microsoftfournissaient les produits autonomes comme MFC (Visual C++), VB, FoxProetc.

En 2002, Microsoft a combiné ses produits et créé un framework .NET. Il existe maintenant une différence entre la façon dont le code était exécuté auparavant et la façon dont le code est géré et exécuté dans .NET Framework. Microsoft a introduit le concept du CLRframework .NET qui compile le code provenant de n'importe quelle langue prise en charge du framework .NET et fournit des fonctionnalités supplémentaires comme memory mangement, garbage collectionetc. Mais, ces fonctionnalités CLR n'étaient pas disponibles directement avant.

Donc, si vous créez une bibliothèque / code dans .NET Framework (compilé avec CLR), cela est appelé Managed code. Vous pouvez utiliser cette bibliothèque davantage dans d'autres applications / projets .NET, et là aussi, CLR comprendra comment elle a été compilée auparavant, et c'est pourquoi elle reste votre code de gestion.

OTOH si vous souhaitez utiliser les bibliothèques qui ont été écrites avant le framework .NET, vous pouvez le faire avec certaines limitations, mais rappelez-vous, puisque CLR n'était pas là à ce moment-là, donc maintenant, CLR ne comprendra pas et ne compilera pas à nouveau ce code . Et cela sera appelé unmanaged code. Veuillez noter que les bibliothèques / assemblages créés par un tiers pour fournir certaines fonctionnalités / certains outils peuvent également être considérés comme du code non géré si ce n'est pas compatible avec CLR.

En termes simples, Gérer le code est quelque chose que votre CLR comprend et peut le compiler seul pour une exécution ultérieure. Dans le framework .NET, (à partir de n'importe quel langage qui fonctionne sur le framework .NET) Lorsque le code va à CLR, le code fournit des informations de métadonnées, afin que CLR puisse vous fournir les fonctionnalités spécifiées ici . Peu d'entre eux le sont, Garbage collection, Performance improvements, cross-language integration, memory managementetc.

OTOH, le code unmanged est quelque chose de spécifique à la machine et prête à l' emploi, pas besoin de traiter davantage.

À partir de Pro C # 5 et du .NET 4.5 Framework:

Code managé ou non managé: Le point le plus important à comprendre à propos du langage C # est qu'il peut produire du code qui ne peut s'exécuter que dans le runtime .NET (vous ne pourriez jamais utiliser C # pour créer un serveur COM natif ou un C / C ++ non managé application). Officiellement, le terme utilisé pour décrire le code ciblant le runtime .NET est du code managé. L'unité binaire qui contient le code managé est appelée un assembly (plus de détails sur les assemblys dans juste un peu). À l'inverse, le code qui ne peut pas être hébergé directement par le runtime .NET est appelé code non managé.