A livello di codice ottenere il numero di versione di una DLL

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

Se si, come?

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

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

Funziona se la dll è .net o Win32 . I metodi di riflessione funzionano solo se la dll è .net. Inoltre, se usi la riflessione, hai il sovraccarico di caricare l'intera dll in memoria. Il metodo seguente non carica l'assembly in memoria.

// Get the file version.
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

fonte originale

Innanzitutto, ci sono due possibili "versioni" che potrebbero interessarti:

• Versione del file system di Windows, applicabile a tutti i file eseguibili

• Versione build dell'assembly, che è integrata in un assembly .NET dal compilatore (ovviamente applicabile solo ai file dll ed exe di assembly .NET)

Nel primo caso, dovresti usare 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 faccia riferimento al proprio codice.

Nota che puoi ignorare tutte le risposte che usano .Load()/ .LoadFrom()metodi, dal momento che questi caricano effettivamente l'assembly nell'attuale AppDomain, che è analogo al tagliare un albero per vedere quanti anni ha.

Ecco un bel modo di usare 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! Class! con il nome di una classe definita nella DLL di cui si desidera ottenere la versione.

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

Per ottenerlo per l'assembly avviato (winform, app console, ecc ...)

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

Kris, la tua versione funziona benissimo quando è necessario caricare l'assembly dal file DLL effettivo (e se la DLL è lì!), Tuttavia, si otterrà un errore molto indesiderato se la DLL è EMBEDDED (ovvero, non un file ma un incorporato DLL).

L'altra cosa è che se si utilizza uno schema di versioning con qualcosa come " 1.2012.0508.0101 ", quando si ottiene la stringa di versione si otterrà effettivamente " 1.2012.518.101 "; notare gli zeri mancanti .

Quindi, ecco alcune funzioni extra per ottenere la versione di una DLL (incorporata 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)

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

La risposta di @Ben si è rivelata utile per me. Ma avevo bisogno di controllare la versione del prodotto in quanto era l'incremento principale nel mio software e seguivo il controllo delle versioni semantico.

myFileVersionInfo.ProductVersion

Questo metodo ha soddisfatto le mie aspettative

Aggiornamento: Invece di menzionare esplicitamente il percorso DLL nel programma (come necessario nella versione di produzione), possiamo ottenere la versione del prodotto usando Assembly.

Assembly assembly = Assembly.GetExecutingAssembly();
FileVersionInfo fileVersionInfo =FileVersionInfo.GetVersionInfo(assembly.Location); 
string ProdVersion= fileVersionInfo.ProductVersion;

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

Mentre la domanda originale potrebbe non essere stata specifica per un servizio Web, ecco un testWebService completo che è possibile aggiungere per visualizzare una risposta non memorizzata nella cache di un servizio Web più la versione del file. Usiamo la versione del file invece della versione dell'assembly perché vogliamo conoscere una versione, ma con tutte le versioni dell'assembly 1.0.0.0, il sito web può essere facilmente patchato (firma e collegamento richiesta ancora attivi!). Sostituisci @ Class @ con il nome del controller API Web in cui è incorporato questo servizio. È utile per andare / andare su un servizio Web più un rapido controllo della versione.

  [Route("api/testWebService")]
  [AllowAnonymous]
  [HttpGet]
  public HttpResponseMessage TestWebService()
  {
      HttpResponseMessage responseMessage = Request.CreateResponse(HttpStatusCode.OK);
      string loc = Assembly.GetAssembly(typeof(@Class@)).Location;
      FileVersionInfo versionInfo = FileVersionInfo.GetVersionInfo(loc);
      responseMessage.Content = new StringContent($"<h2>The XXXXX web service GET test succeeded.</h2>{DateTime.Now}<br/><br/>File Version: {versionInfo.FileVersion}");
      responseMessage.Content.Headers.ContentType = new MediaTypeHeaderValue("text/html");
      Request.RegisterForDispose(responseMessage);
      return responseMessage;
  }

Ho trovato anche necessario aggiungere quanto segue a web.config in configurazione per renderlo veramente anonimo

<location path="api/testwebservice">
    <system.web>
        <authorization>
            <allow users="*" />
        </authorization>
    </system.web>
</location>