Ottieni automaticamente il numero di versione di una DLL

Question

È possibile ottenere il numero di versione a livello di programmazione da qualsiasi DLL .NET?

Se sì, come?

Answer 1

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

Importante: Va notato che questa non è la migliore risposta alla domanda iniziale. Non dimenticare di leggere di più su questa pagina.

Answer 2

È possibile utilizzare i metodi System.Reflection.Assembly.Load *() e quindi prendere il loro AssemblyInfo.

Answer 3

di farlo per l'assemblea che è stato avviato (WinForm, console app, ecc ...)

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

Answer 4

Kris, la versione funziona alla grande quando hanno bisogno di caricare l'assembly dal file DLL effettiva (e se la DLL è lì!), tuttavia, si otterrà un errore molto indesiderato se la DLL è EMBEDDED (cioè, non un file ma una DLL incorporata).

L'altra cosa è, se si utilizza un sistema di controllo delle versioni con qualcosa come "1.2012.0508.0101", quando si ha la stringa della versione ci troveremo a ottenere "1.2012.518.101"; note gli zeri mancanti.

Quindi, ecco un paio di funzioni extra per ottenere la versione di una DLL (incorporato o dal file 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

Ecco un bel modo con un po 'di riflessione per ottenere una versione di una DLL contenente una particolare classe:

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

Basta sostituire! Classe! con il nome di una classe che è definita nella DLL che si desidera ottenere la versione di.

Questo è il mio metodo preferito perché se sposto le DLL in giro per distribuzioni diverse non devo modificare il percorso file.

Answer 7

Questo funziona se la DLL è .net o Win32. I metodi di riflessione funzionano solo se la DLL è .net. Inoltre, se si utilizza la riflessione, si ha il sovraccarico di caricare l'intera DLL in memoria. Il metodo seguente non carica l'assembly in memoria.

// 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); 

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

original source

Answer 8

Prima di tutto, ci sono due possibili 'versioni' che potreste essere interessati a:

• Windows versione del file system, applicabile a tutti i file eseguibili

• Assembly build version, che è incorporato in un assembly .NET dal compilatore (ovviamente applicabile solo a.File dll ed exe di assembly NET)

Nel primo caso, è necessario utilizzare la risposta di Ben Anderson; in quest'ultimo caso, utilizzare AssemblyName.GetAssemblyName(@"c:\path\to\file.dll").Version o la risposta di Tataro, nel caso in cui l'assembly sia referenziato dal proprio codice.

Si noti che è possibile ignorare tutte le risposte che utilizzano i metodi .Load()/.LoadFrom(), poiché questi effettivamente caricano l'assembly nell'AppDomain corrente, il che è analogo all'abbattimento di un albero per vedere quanti anni ha.