web-dev-qa-db-fra.com

Comment obtenir le numéro de version du fichier .exe à partir du chemin du fichier

J'utilise .Net 3.5/4.0 avec du code en C #.

J'essaie d'obtenir le numéro de version d'un fichier exe sur mon lecteur C :. 

Par exemple, chemin est: c:\Program\demo.exe. Si le numéro de version de demo.exe est 1.0.

Comment puis-je utiliser ce chemin pour récupérer le numéro de version?. 

c#-4.0versionfileversioninfo
58
NoviceMe

Vous pouvez utiliser FileVersionInfo.ProductVersion pour le récupérer depuis un chemin.

var versionInfo = FileVersionInfo.GetVersionInfo(pathToExe);
string version = versionInfo.ProductVersion; // Will typically return "1.0.0" in your case
121
Reed Copsey

2018 mis à jour et modernisé (par exemple, interpolation de chaîne de C # 6):

La réponse acceptée est en partie incorrecte (ProductVersion ne renvoie généralement pas de version en trois parties) et un peu trompeuse:

Voici une réponse plus complète. Pour que le texte principal ne soit pas trop long, je l'ai divisé en un résumé plus court, ce qui peut être "suffisant" pour beaucoup de gens. Vous n'êtes pas obligé de lire la seconde partie détaillée, alors s'il vous plait non tl; dr :-)

Court résumé:

  1. Il existe différentes versions (version Assembly, version du fichier, version du produit) de chaque fichier, mais normalement, vous les aurez toutes égales pour ne pas obtenir "version enfer" déjà au niveau du fichier (cela arrivera suffisamment tôt).

  2. La version du fichier (visible dans l'explorateur et utilisée dans les configurations/installations) est ce que je nommerais le plus important.

  3. Pour cela, commentez simplement la variation de fil dans le fichier AssemblyInfo.cs comme ci-dessous. Cela garantit que les trois versions différentes possibles d'un fichier sont identiques!

    [Assembly: AssemblyVersion ("1.1.2 .")]]
    // [Assembly: AssemblyFileVersion ("1.1.2.    ")]

  4. Par exemple. pour le versioning sémantique, vous voulez obtenir seulement 3 parties de version sur 4:

Il est utile d’avoir un décompte de construction automatique pour chaque construction de Visual Studio. Mais ce comptage de builds n’est pas toujours utile pour informer vos clients, internes ou externes. Donc, pour mentionner la version du fichier dans Windows, dans les dialogues de titre, je vous conseillerais de ne montrer que trois parties v1.2.3 (et bien sûr avec la gestion sémantique):

using System.Diagnostics;
...

var versInfo= FileVersionInfo.GetVersionInfo(pathToVersionedFile); 
string fileVersionFull = versInfo.FileVersion; // No difference here for versinfo.ProductVersion if recommendation in AssemblyInfo.cs is followed
string fileVersionSemantic = $"V{versInfo.FileMajorPart}.{versInfo.FileMinorPart}.{versInfo.FileBuildPart}";
string fileVersionFull2 =    $"V{versInfo.FileMajorPart}.{versInfo.FileMinorPart}.{versInfo.FileBuildPart}.{versInfo.FilePrivatePart}";

(FileVersionFull2} montre simplement comment gérer les 4 parties, sauf que le "V" contient la même chose que FileVersionFull. 

Détails:

Premièrement, un aide-mémoire explique comment obtenir et définir les trois versions:

Version du fichier: [Assembly: AssemblyFileVersion (..)] => System.Diagnostics.FileVersionInfo.FileVersion 

Version du produit: [Assembly: AssemblyInformationalVersion (..)] => System.Diagnostics.FileVersionInfo.ProductVersion 

Assembly version: [Assembly: AssemblyVersion (..)] => System.Reflection.Assembly.Version

En particulier, le défaut peut être déroutant. Lien recommandé SO pour comprendre les détails: FileVersionInfo et AssemblyInfo

EntryAssembly ou ExecutingAssembly
Pour prendre pleinement en compte tous les cas pour obtenir la version de l'application en cours d'exécution, recherchez ailleurs pour plus de détails, par exemple. ici: Quel est le meilleur moyen d'obtenir l'emplacement de Assembly, GetAssembly (). Location ou GetExecutingAssembly (). Location
En particulier, il peut y avoir confusion si EntryAssembly ou ExecutingAssembly doivent être utilisés. Ils ont tous deux des avantages et des mises en garde. Si le code suivant n'est pas dans le même assemblage que le fichier .exe, par exemple. dans une assemblée auxiliaire, les choses se compliquent. Habituellement, vous utiliseriez ensuite EntryAssembly pour obtenir la version du fichier .exe.
Mais: pour les tests unitaires dans Visual Studio destinés à tester les routines dans un projet .exe parallèle, GetEntryAssembly () ne fonctionne pas (mon env: NUnit, VS2017). Mais GetExecutingAssembly () ne plante pas du moins, vous obtenez uniquement la version Assembly du projet test. Bien assez pour moi. Il peut y avoir des situations qui ne sont pas aussi simples.
Si vous le souhaitez, vous pouvez omettre la déclaration sous forme statique, ce qui permet d'obtenir des versions de plusieurs assemblys différents dans un programme.

public static class AppInfo
{
  public static string FullAssemblyName { get; }
  ..

  static AppInfo()
  {
      Assembly thisAssembly = null;
      try
      {
          thisAssembly = Assembly.GetEntryAssembly();
      }
      finally
      {
          if (thisAssembly is null)
              thisAssembly = Assembly.GetExecutingAssembly();
      }
      FullAssemblyName = thisAssembly.Location;
      var versInfo = FileVersionInfo.GetVersionInfo(FullAssemblyName);
      ..
  }
}

Version du produit ou version du fichier:
ProductVersion d'un fichier est également affiché dans l'Explorateur Windows. Je recommanderais de différencier au maximum ProductVersion et FileVersion dans le fichier le plus "visible par le client" (principalement le fichier principal .exe de l'application). Mais ce pourrait être bien sûr un choix de différencier pour chaque fichier de l'application "principale" et de leur laisser tous la "Marketing" Version "marketing" qui est vue par le client . Mais l'expérience montre que ce n'est ni nécessaire ni bon marché pour essayer de trop synchroniser les versions techniques et les versions marketing. La confusion ne diminue pas vraiment, les coûts augmentent. Donc, la solution décrite dans la première partie devrait le faire principalement. 

Historique: version de Assembly par rapport à la version du fichier: L'une des raisons pour lesquelles différentes versions sont disponibles est également qu'un .NET Assembly peut à l'origine se composer de plusieurs fichiers (modules) - en théorie. Ceci n'est pas utilisé par Visual Studio et très rarement ailleurs. C’est peut-être une raison historique de donner la possibilité de différencier ces deux versions ..__ Techniquement, la version d’Assembly est pertinente pour la gestion des versions liées à .NET en tant que GAC et versions côte à côte, la version du fichier étant plus pertinente pour les installations classiques, par exemple. écrasement lors des mises à jour ou des fichiers partagés.

23
Philm

Dans la réponse acceptée, il est fait référence à "pathToExe".

Ce chemin peut être récupéré et utilisé comme suit:

var Assembly = Assembly.GetExecutingAssembly();
var fvi = FileVersionInfo.GetVersionInfo(Assembly.Location);
var version = fvi.FileVersion; // or fvi.ProductVersion

J'espère que cela évitera à quelqu'un de faire des démarches inutiles.

18
Sophtware

Où Program est le nom de votre classe:

Console.WriteLine("Version = " + typeof(Program).Assembly.GetName().Version.ToString()) ;
6
Ralf

Je ne sais pas si c'est ce que vous cherchez, mais:

http://www.daniweb.com/software-development/csharp/threads/276174/c-code-to-get-dll-version

Ça dit 

int i;

// Get the file version for the notepad.
FileVersionInfo.GetVersionInfo(Path.Combine(Environment.SystemDirectory, "notepad.exe"));

FileVersionInfo myFileVersionInfo =  FileVersionInfo.GetVersionInfo(Environment.SystemDirectory + "\\notepad.exe");

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

Utilisez, ça marche:

using System.Reflection;

string v = AssemblyName.GetAssemblyName("Path/filename.exe").Version.ToString();
2
phuc.nx
//Example your file version is 1.0.0.0
//Solution 1
Dim fileVer As FileVersionInfo = FileVersionInfo.GetVersionInfo(Environment.CurrentDirectory + "\yourExe.exe")
yourLabel.Text = fileVer.FileVersion
//Solution 2
//Get File Version Number
yourLabel.Text = Application.ProductVersion
//Both solution will get output 1.0.0.0
0
Tuan Zaidi