Obtenir par programme le numéro de version d'une DLL

Question

Est-il possible d'obtenir le numéro de version par programmation à partir de n'importe quelle DLL .NET?

Si oui, comment?

Answer 1

Assembly assembly = Assembly.LoadFrom("MyAssembly.dll"); 
Version ver = assembly.GetName().Version; 

Important: Il convient de noter que ce n'est pas la meilleure réponse à la question initiale. N'oubliez pas d'en lire plus sur cette page.

Answer 2

Vous pouvez utiliser les méthodes System.Reflection.Assembly.Load *(), puis récupérer leur AssemblyInfo.

Answer 3

Pour l'obtenir pour l'assemblage qui a été lancé (WinForm, application de la console, etc ...)

using System.Reflection; 
... 
Assembly.GetEntryAssembly().GetName().Version 

Answer 4

Kris, votre version fonctionne très bien quand besoin de charger l'ensemble du fichier DLL réelle (et si la DLL est là!), cependant, on obtiendra une erreur indésirable si la DLL est EMBEDDED (c'est-à-dire, pas un fichier mais une DLL incorporée).

L'autre chose est, si l'on utilise un système de versioning avec quelque chose comme « 1.2012.0508.0101 », quand on obtient la chaîne de version, vous obtenez réellement « 1.2012.518.101 »; notez les zéros manquants.

Alors, voici quelques fonctions supplémentaires pour obtenir la version d'une DLL (intégrée ou à partir du fichier DLL):

public static System.Reflection.Assembly GetAssembly(string pAssemblyName) 
    { 
     System.Reflection.Assembly tMyAssembly = null; 

     if (string.IsNullOrEmpty(pAssemblyName)) { return tMyAssembly; } 
     tMyAssembly = GetAssemblyEmbedded(pAssemblyName); 
     if (tMyAssembly == null) { GetAssemblyDLL(pAssemblyName); } 

     return tMyAssembly; 
    }//System.Reflection.Assembly GetAssemblyEmbedded(string pAssemblyDisplayName) 


    public static System.Reflection.Assembly GetAssemblyEmbedded(string pAssemblyDisplayName) 
    { 
     System.Reflection.Assembly tMyAssembly = null; 

     if(string.IsNullOrEmpty(pAssemblyDisplayName)) { return tMyAssembly; } 
     try //try #a 
     { 
      tMyAssembly = System.Reflection.Assembly.Load(pAssemblyDisplayName); 
     }// try #a 
     catch (Exception ex) 
     { 
      string m = ex.Message; 
     }// try #a 
     return tMyAssembly; 
    }//System.Reflection.Assembly GetAssemblyEmbedded(string pAssemblyDisplayName) 


    public static System.Reflection.Assembly GetAssemblyDLL(string pAssemblyNameDLL) 
    { 
     System.Reflection.Assembly tMyAssembly = null; 

     if (string.IsNullOrEmpty(pAssemblyNameDLL)) { return tMyAssembly; } 
     try //try #a 
     { 
      if (!pAssemblyNameDLL.ToLower().EndsWith(".dll")) { pAssemblyNameDLL += ".dll"; } 
      tMyAssembly = System.Reflection.Assembly.LoadFrom(pAssemblyNameDLL); 
     }// try #a 
     catch (Exception ex) 
     { 
      string m = ex.Message; 
     }// try #a 
     return tMyAssembly; 
    }//System.Reflection.Assembly GetAssemblyFile(string pAssemblyNameDLL) 


    public static string GetVersionStringFromAssembly(string pAssemblyDisplayName) 
    { 
     string tVersion = "Unknown"; 
     System.Reflection.Assembly tMyAssembly = null; 

     tMyAssembly = GetAssembly(pAssemblyDisplayName); 
     if (tMyAssembly == null) { return tVersion; } 
     tVersion = GetVersionString(tMyAssembly.GetName().Version.ToString()); 
     return tVersion; 
    }//string GetVersionStringFromAssemblyEmbedded(string pAssemblyDisplayName) 


    public static string GetVersionString(Version pVersion) 
    { 
     string tVersion = "Unknown"; 
     if (pVersion == null) { return tVersion; } 
     tVersion = GetVersionString(pVersion.ToString()); 
     return tVersion; 
    }//string GetVersionString(Version pVersion) 


    public static string GetVersionString(string pVersionString) 
    { 
     string tVersion = "Unknown"; 
     string[] aVersion; 

     if (string.IsNullOrEmpty(pVersionString)) { return tVersion; } 
     aVersion = pVersionString.Split('.'); 
     if (aVersion.Length > 0) { tVersion = aVersion[0]; } 
     if (aVersion.Length > 1) { tVersion += "." + aVersion[1]; } 
     if (aVersion.Length > 2) { tVersion += "." + aVersion[2].PadLeft(4, '0'); } 
     if (aVersion.Length > 3) { tVersion += "." + aVersion[3].PadLeft(4, '0'); } 

     return tVersion; 
    }//string GetVersionString(Version pVersion) 


    public static string GetVersionStringFromAssemblyEmbedded(string pAssemblyDisplayName) 
    { 
     string tVersion = "Unknown"; 
     System.Reflection.Assembly tMyAssembly = null; 

     tMyAssembly = GetAssemblyEmbedded(pAssemblyDisplayName); 
     if (tMyAssembly == null) { return tVersion; } 
     tVersion = GetVersionString(tMyAssembly.GetName().Version.ToString()); 
     return tVersion; 
    }//string GetVersionStringFromAssemblyEmbedded(string pAssemblyDisplayName) 


    public static string GetVersionStringFromAssemblyDLL(string pAssemblyDisplayName) 
    { 
     string tVersion = "Unknown"; 
     System.Reflection.Assembly tMyAssembly = null; 

     tMyAssembly = GetAssemblyDLL(pAssemblyDisplayName); 
     if (tMyAssembly == null) { return tVersion; } 
     tVersion = GetVersionString(tMyAssembly.GetName().Version.ToString()); 
     return tVersion; 
    }//string GetVersionStringFromAssemblyEmbedded(string pAssemblyDisplayName) 

Answer 5

var versionAttrib = new AssemblyName(Assembly.GetExecutingAssembly().FullName); 

Answer 6

Voici une belle façon avec un peu de réflexion pour obtenir une version d'une DLL contenant une classe particulière:

var ver = System.Reflection.Assembly.GetAssembly(typeof(!Class!)).GetName().Version; 

Remplacez simplement! Class! avec le nom d'une classe qui est définie dans la DLL dont vous souhaitez obtenir la version.

Ceci est ma méthode préférée car si je déplace les DLL pour différents déploiements, je n'ai pas besoin de changer le chemin du fichier.

Answer 7

Cela fonctionne si la DLL est .net ou Win32. Les méthodes de réflexion ne fonctionnent que si la DLL est .net. En outre, si vous utilisez la réflexion, vous avez la charge de charger la DLL entière dans la mémoire. La méthode ci-dessous ne charge pas l'assembly en mémoire.

// Get the file version for the notepad. 
FileVersionInfo myFileVersionInfo = FileVersionInfo.GetVersionInfo(@"C:\MyAssembly.dll"); 

// Print the file name and version number. 
Console.WriteLine("File: " + myFileVersionInfo.FileDescription + '\n' + 
        "Version number: " + myFileVersionInfo.FileVersion); 

De: http://msdn.microsoft.com/en-us/library/system.diagnostics.fileversioninfo.fileversion.aspx

original source

Answer 8

Tout d'abord, il y a deux 'versions' possibles que vous pourriez être intéressé par:

• de Windows version du fichier du système de fichiers, applicable à tous les fichiers exécutables

• Version de construction d'assembly, qui est incorporée dans un assembly .NET par le compilateur (évidemment applicable uniquement à.Fichiers dll et exe d'assemblage NET)

Dans le premier cas, vous devriez utiliser la réponse de Ben Anderson; dans ce dernier cas, utilisez AssemblyName.GetAssemblyName(@"c:\path\to\file.dll").Version, ou la réponse de Tataro, dans le cas où l'assembly est référencé par votre code. Notez que vous pouvez ignorer toutes les réponses qui utilisent les méthodes .Load()/.LoadFrom(), puisque celles-ci chargent réellement l'assembly dans l'AppDomain actuel - ce qui revient à couper un arbre pour voir son âge.