Versions du journal de toutes les DLL utilisées

Question

Je veux enregistrer les versions de toutes les DLL que mon application .NET utilise. Peu importe si la sortie de journal est générée au démarrage ou lors de la première utilisation de chaque DLL.

La première solution qui m'est venue à l'esprit était de parcourir tous les fichiers DLL qui résident dans le même répertoire que mon assembly. Mais est-ce la meilleure option que j'ai? Y a-t-il une meilleure façon de faire cela? Il est important que la solution fonctionne également sur .NET-Compact-Framework.

Answer 1

Modifier: J'ai testé et vérifié que cela fonctionne sur le .NET Compact Framework.

Vous pouvez le faire en utilisant Mono.Cecil, un outil puissant qui vous permet d'ouvrir et d'inspecter des assemblys .NET au niveau IL sans même les charger dans un AppDomain.

string path = System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase; 

// If using Mono.Cecil 0.6.9.0: 
AssemblyDefinition myAssembly = AssemblyFactory.GetAssembly(path); 

// If using Mono.Cecil 0.9.1.0: 
AssemblyDefinition myAssembly = AssemblyDefinition.ReadAssembly(path); 

// from there, you can inspect the assembly's references 
foreach (ModuleDefinition module in myAssembly.Modules) 
{ 
    foreach (AssemblyNameReference assemblyReference in module.AssemblyReferences) 
    { 
     // do something with the reference e.g get name, version, etc 
     string fullName = assemblyReference.FullName; 
     Version version = assemblyReference.Version; 
    } 
} 

Answer 2

Je ne suis pas sûr si elle est disponible sur CF, mais en .NET normal, j'utiliserais simplement AppDomain.GetAssemblies().

Vous pouvez utiliser l'événement AppDomain.AssemblyLoad pour vous avertir lorsqu'un assemblage est chargé.

Answer 3

Vous pouvez utiliser le Dependency Walker et utiliser les options de ligne de commande pour l'exécuter en tant que sous-processus. Selon la FAQ, cela fonctionne contre les modules Windows CE, bien qu'il ne fonctionne pas sur les appareils CE, ce qui peut ne pas convenir à vos besoins.

Answer 4

Utilisez l'événement AppDomain.AssemblyLoad.

par exemple.

AppDomain.CurrentDomain.AssemblyLoad+=(s, e) => 
    Console.WriteLine("loaded: "+e.LoadedAssembly.FullName); 

Answer 5

public void LogAssemblies() 
{ 
    foreach(Assembly asm in AppDomain.CurrentDomain.GetAssemblies()) 
    { 
    AssemblyName assemblyName = asm.GetName(); 
    string simpleName = assemblyName.Name; 
    string version = assemblyName.Version.ToString(); 
    // do something with these 
    } 
} 

EDIT: Woops, ressemble AppDomain.GetAssemblies() ne sont pas dans le cadre compact.

Answer 6

je suppose un algorithme intéressant serait de sérialiser les assemblées que vous utilisez, puis, lors du démarrage, vous désérialiser votre configuration et comparez avec la version que vous avez de chaque DLL. Ensuite, lors de la mise à jour de la version, vous sérialisez une nouvelle version de votre configuration et consignez le nom et la version de votre assembly dans votre fichier journal. Gardez à l'esprit que la chose la plus importante à considérer est de faire ce que vous devez faire. Rien d'autre ne compte. Une fois qu'il fait le travail dont vous avez besoin, il y a peut-être place à amélioration. Mais d'abord, faites-le fonctionner! Vous verrez simplement ce qui doit être amélioré par la suite.