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

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

Si oui, comment?

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 de lire plus sur cette page.

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

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

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

source primaire

Tout d'abord, il existe deux `` versions '' possibles qui pourraient vous intéresser:

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

• Version de build d'assembly, qui est incorporée dans un assembly .NET par le compilateur (évidemment uniquement applicable aux fichiers DLL et exe de l'assembly .NET)

Dans le premier cas, vous devriez utiliser la réponse de Ben Anderson; dans ce dernier cas, utilisezAssemblyName.GetAssemblyName(@"c:\path\to\file.dll").Version , ou la réponse de Tataro, au cas où l'assemblage serait référencé par votre code.

Notez que vous pouvez ignorer toutes les réponses qui utilisent .Load()/ .LoadFrom()methods, car elles chargent en fait l'assembly dans l'AppDomain actuel - ce qui revient à couper un arbre pour voir son âge.

Voici une belle façon d'utiliser 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! Classe! avec le nom d'une classe qui est définie dans la DLL dont vous souhaitez obtenir la version.

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

Pour l'obtenir pour l'assembly qui a été démarré (winform, application console, etc ...)

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

Kris, votre version fonctionne très bien lorsque vous avez besoin de charger l'assembly à partir du fichier DLL réel (et si la DLL est là!), Cependant, on obtiendra une erreur très indésirable si la DLL est EMBEDDED (c'est-à-dire, pas un fichier mais un intégré DLL).

L'autre chose est que si l'on utilise un schéma de version avec quelque chose comme " 1.2012.0508.0101 ", quand on obtient la chaîne de version, vous obtiendrez en fait " 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)

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

La réponse de @Ben s'est avérée utile pour moi. Mais j'avais besoin de vérifier la version du produit car c'était le principal incrément qui se passait dans mon logiciel et suivait le versionnage sémantique.

myFileVersionInfo.ProductVersion

Cette méthode a répondu à mes attentes

Mise à jour: au lieu de mentionner explicitement le chemin de la dll dans le programme (comme nécessaire dans la version de production), nous pouvons obtenir la version du produit en utilisant Assembly.

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

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

Bien que la question d'origine ne soit pas spécifique à un service Web, voici un testWebService complet que vous pouvez ajouter pour afficher une réponse de service Web non mise en cache plus la version du fichier. Nous utilisons la version fichier au lieu de la version d'assembly parce que nous voulons connaître une version, mais avec toutes les versions d'assembly 1.0.0.0, le site Web peut être facilement patché (signature et lien de demande toujours actifs!). Remplacez @ Class @ par le nom du contrôleur de l'API Web dans lequel ce service est intégré. C'est bon pour un go / nogo sur un service Web plus une vérification rapide de la version.

  [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;
  }

J'ai trouvé qu'il était également nécessaire d'ajouter ce qui suit à web.config sous configuration pour le rendre vraiment anonyme

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