c#-4.0 - ubicacion - string filename application startuppath

Cómo obtener el número de versión del archivo.exe de la ruta del archivo

Question

Estoy utilizando .Net 3.5 / 4.0 con código en C #.

Estoy intentando obtener un número de versión de un archivo exe en mi unidad C :.

Por ejemplo, la ruta es: c: / Program / demo.exe. Si el número de versión de demo.exe es 1.0.

¿Cómo puedo usar esta ruta para tomar el número de versión?

Answer 1

2018 actualizado y modernizado (por ejemplo, interpolación de cadenas de C # 6):

La respuesta aceptada en parte no es correcta (ProductVersion no suele devolver una versión de tres partes) y es un poco engañoso:

Aquí hay una respuesta más completa. Para obtener el texto principal, no demasiado largo, lo dividí en un breve resumen que puede ser "suficiente" para muchas personas. No está obligado a leer la segunda parte detallada, así que por favor no tl; dr :-)

Breve resumen:

1. Hay diferentes versiones (versión de ensamblaje, versión de archivo, versión de producto) de cada archivo, pero normalmente las tendrá todas iguales para no tener "versión infierno" ya en el nivel de archivo (llegará lo suficientemente pronto).

2. La versión del archivo (que es visible en Explorer y se usa en configuraciones / instalaciones) es, lo que yo llamaría la más importante para molestar.

3. Para lograr esto, simplemente comente la versión de archivo en el archivo AssemblyInfo.cs como se muestra a continuación. ¡Esto asegura que las tres versiones diferentes posibles de un archivo son las mismas!

   [ensamblado: AssemblyVersion ("1.1.2. ")]
   // [assembly: AssemblyFileVersion ("1.1.2. ")]

4. Por ejemplo, para el control de versiones semántico desea obtener solo 3 partes de la versión de 4 posibles:

Tener una cuenta de compilación automática para cada compilación de Visual Studio es útil. Pero este conteo de compilación no siempre es útil para informar a sus clientes, internos o externos. Por lo tanto, para mencionar la versión del archivo en Windows, en los diálogos de títulos, aconsejaría mostrar solo tres partes v1.2.3 (y, por supuesto, con versiones semánticas):

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 solo muestra cómo manejar las 4 partes, excepto la "V" que contiene lo mismo que FileVersionFull .

D etails:

Primero está una hoja de trucos sobre cómo obtener y configurar las tres versiones:

Versión del archivo: [assembly: AssemblyFileVersion (..)] => System.Diagnostics.FileVersionInfo.FileVersion

Versión del producto: [assembly: AssemblyInformationalVersion (..)] => System.Diagnostics.FileVersionInfo.ProductVersion

Versión de ensamblaje: [ensamblado: AssemblyVersion (..)] => System.Reflection.Assembly.Version

Especialmente el incumplimiento puede ser confuso. Enlace SO recomendado para comprender los detalles: FileVersionInfo y AssemblyInfo

EntryAssembly vs. ExecutingAssembly
Para considerar completamente cada caso para obtener la versión de la aplicación en ejecución, busque en otro lugar para obtener más detalles, por ejemplo, aquí: cuál es mejor para obtener la ubicación del ensamblaje, GetAssembly (). Location o GetExecutingAssembly (). Location
Especialmente, puede haber confusión, si se debe utilizar EntryAssembly o ExecutingAssembly. Ambos tienen ventajas y advertencias. Si tiene el siguiente código que no está en el mismo ensamblaje que el .exe, por ejemplo, en un ensamblaje auxiliar, las cosas se complican. Por lo general, usaría EntryAssembly para obtener la versión del archivo .exe.
Pero: Para las pruebas unitarias en Visual Studio para probar rutinas en un proyecto .exe paralelo, GetEntryAssembly () no funciona (mi env: NUnit, VS2017). Pero GetExecutingAssembly () no falla al menos, solo durante la prueba de unidad se obtiene la versión de ensamblaje del proyecto de prueba. Lo suficientemente bien para mí. Puede haber situaciones que no sean tan simples.
Si lo desea, puede omitir la declaración como estática, lo que hace que sea realmente posible obtener versiones de varios ensamblajes diferentes en un solo programa.

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);
      ..
  }
}

Versión del producto vs. versión del archivo:
ProductVersion de un archivo también se muestra en el Explorador de Windows. Recomendaría diferenciar al máximo ProductVersion y FileVersion en el archivo más "visible para el cliente" (principalmente el archivo .exe principal de la aplicación). Pero, por supuesto, podría ser una opción para diferenciar cada archivo de la aplicación "principal" y permitir que todos tengan toda la versión de marketing que se ve por el cliente. Pero la experiencia demuestra que no es necesario ni barato intentar sincronizar demasiado las versiones técnicas y las de marketing. La confusión no disminuye realmente, los costos aumentan. Así que la solución descrita en la primera parte aquí debería hacerlo principalmente.

Historial: versión de ensamblaje frente a versión de archivo: una razón para tener versiones diferentes también es que un ensamblado .NET puede consistir originalmente en varios archivos (módulos), en teoría. Esto no lo usa Visual Studio y muy raramente se usa en otros lugares. Esta quizás una razón histórica de dar la posibilidad de diferenciar estas dos versiones. Técnicamente, la versión de ensamblaje es relevante para las versiones relacionadas con .NET como GAC y versiones en paralelo, la versión de archivo es más relevante para configuraciones clásicas, por ejemplo, sobrescribir durante actualizaciones o para archivos compartidos.

Answer 2

Donde Program es tu nombre de clase:

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

Answer 3

En la respuesta aceptada se hace una referencia a "pathToExe".

Esta ruta se puede recuperar y utilizar de la siguiente manera:

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

Espero que esto salve a alguien de hacer algunos pasos adicionales innecesarios.

Answer 4

No estoy seguro de si esto es lo que está buscando, pero:

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

Dice

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

Answer 5

Puede usar FileVersionInfo.ProductVersion para obtener esto de una ruta.

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

Answer 6

Usa, funciona:

using System.Reflection;

string v = AssemblyName.GetAssemblyName("Path/filename.exe").Version.ToString();

Answer 7

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