Comment les DLL sont-elles chargées par le CLR?
Mon idée a toujours été que le CLR chargé toutes les Dll nécessaires au démarrage du domaine de l'application. Cependant, j'ai écrit un exemple qui me fait douter de cette hypothèse. Je lance mon application et vérifier pour voir comment de nombreux modules sont chargés.
Process[] ObjModulesList;
ProcessModuleCollection ObjModulesOrig;
//Get all modules inside the process
ObjModulesList = Process.GetProcessesByName("MyProcessName");
//Populate the module collection.
ObjModulesOrig = ObjModulesList[0].Modules;
Console.WriteLine(ObjModulesOrig.Count.ToString());
Je puis répétez exactement le même code et mon compte est différent. La DLL est C:\WINNT\system32\version.dll.
Je suis vraiment confus quant à pourquoi le compte serait différent.
Quelqu'un pourrait-il donner des précisions sur ce que le CLR est fait et comment il le chargement de ces choses, et en ce que la logique c'est de le faire?
source d'informationauteur priehl
Vous devez vous connecter pour publier un commentaire.
La suite copié à partir de N'Boîte excellente Essentiel .Net. (disponible ici)
(et, à mon humble avis, un must pour tous les professionnels .Net developer)
Le CLR Chargeur
Le CLR Chargeur est responsable du chargement et l'initialisation des assemblées, des modules, des ressources et des types. Le CLR chargeur charge et initialise aussi peu qu'il le peut. Contrairement aux Win32 chargeur, le CLR chargeur ne permet pas de résoudre et de charger automatiquement le subordonné modules (ou ensembles).
Plutôt, le subordonné, les pièces sont chargées à la demande que si elles sont réellement nécessaires (comme avec Visual C++ 6.0, le retard d'-fonction de chargement). Ce n'accélère pas seulement de l'initialisation du programme le temps, mais également de réduire la quantité de ressources consommées par l'exécution d'un programme.
Dans le CLR, le chargement est généralement déclenchée par le juste à temps (JIT) compilateur basé sur des types. Lorsque le compilateur JIT essaie de convertir un corps de méthode de CIL en code machine, elle a besoin d'accéder à la définition du type de déclarer le type ainsi que le type de définitions pour le type de champs. De plus, le compilateur JIT également besoin d'accéder au type de définitions utilisées par les variables locales ou des paramètres de la méthode JIT-compilé. Chargement d'un type implique le chargement de l'assemblée et le module qui contient la définition de type.
Cette politique de chargement de types (et d'assemblages et de modules) sur demande des parties d'un programme qui ne sont pas utilisés ne sont jamais mis en mémoire. Cela signifie également qu'une application en cours d'exécution verrez souvent des nouvelles assemblées et des modules chargés au fil du temps que les types contenues dans ces fichiers sont nécessaires lors de l'exécution. Si ce n'est pas le comportement que vous voulez, vous avez deux options. L'un est de simplement déclarer caché champs statiques des types que vous souhaitez interagir avec le chargeur de manière explicite.
Le chargeur ne dispose généralement de son travail implicitement sur votre nom. Les développeurs peuvent interagir avec le chargeur explicitement par l'assemblée chargeur. L'assemblée chargeur est exposée aux développeurs via le
LoadFrom
méthode statique sur leSystem.Reflection.Assembly
classe. Cette méthode accepte un CODE de la chaîne, qui peut être soit un chemin du système de fichier ou d'une URL (uniform resource locator) qui identifie le module contenant le manifeste de l'assembly. Si le fichier spécifié ne peut être trouvé, le chargeur va jeter unSystem.FileNotFoundException
exception. Si le fichier spécifié, mais peut être trouvé n'est pas un module CLR contenant un manifeste d'assembly, le chargeur va jeter unSystem.BadImageFormatException
exception. Enfin, si le CODE est une URL qui utilise un régime autre quefile:
l'appelant doit avoir WebPermission droits d'accès ou d'autre unSystem.SecurityException
exception est levée. En outre, les assemblées, les Url avec les autres protocoles quefile:
sont tout d'abord téléchargé sur le cache de téléchargement avant d'être chargé.Listing 2.2 montre un simple programme C# qui charge une assemblée situé à
file://C:/usr/bin/xyzzy.dll
puis crée une instance du type nomméAcmeCorp.LOB.Customer
. Dans cet exemple, tout ce qui est fourni par l'appelant est l'emplacement physique de l'assemblée.Lorsqu'un programme utilise l'assemblée chargeur dans ce mode, le CLR ignore le nom en quatre parties de l'assemblée, y compris son numéro de version.
L'exemple 2. 2. Chargement d'une Assemblée Explicite CODEBASE
Bien que le chargement des assemblages par emplacement est un peu intéressant, la plupart des assemblées sont chargés par le nom à l'aide de l'assemblée de résolution. L'assemblée résolveur utilise dans les quatre parties du nom de l'assembly pour déterminer qui sous-tendent le fichier à charger dans la mémoire à l'aide de l'assemblée chargeur. Comme indiqué dans Figure 2.9ce nom à l'emplacement processus de résolution prend en compte une variété de facteurs, y compris le répertoire de l'application est hébergée dans les, la gestion des versions des politiques, et d'autres détails de la configuration (qui sont décrits plus loin dans ce chapitre).
L'assemblée résolveur est exposée aux développeurs via le
Load
méthode de laSystem.Reflection.Assembly
classe. Comme le montre le Listing 2.3, cette méthode accepte un quatre-ensemble de pièce de nom (comme une chaîne ou un AssemblyName de référence) et superficiellement semble être similaire à la méthode LoadFrom exposés par l'assemblée chargeur. La similitude est que la peau en profondeur, parce que le Chargement d'abord la méthode utilise l'assemblée de résolution pour trouver un fichier à l'aide d'une assez complexe de la série d'opérations. La première de ces opérations est d'appliquer une politique de version de déterminer exactement quelle est la version de l'assemblage souhaitée doit être chargé.L'exemple 2.3. Chargement d'une Assemblée à l'Aide de l'Assemblée de résolution
Le CLR charge les assemblées à la demande. Lorsque vous exécutez une méthode, il attend de voir où il est (qui module etc.), et si elle n'est pas chargée, il le charge.
Voici un l'article sur la performance CLR et les discussions sur le chargement des assemblages:
Ce l'article est pour SilverLight, mais il ne parle un peu sur ce qui se passe avec le CLR.
C'est un peu hors de votre question, mais vous pouvez charger toutes les assemblées, à la fois si vous préférez ne pas avoir à se produire sur demande. Quelque chose comme ceci devrait faire l'affaire
COM DLL sont chargées à la demande chaque fois que le COM objet est créé. Ce pourrait aussi être le cas avec les dll COM.