Saber la versión de un ejecutable
(o ensamblado)

Publicado el 18/Sep/2003
Actualizado el 24/Jun/2008

24/Jun/08: Si quieres un código más simple para averiguar la versión de un EXE o DLL

Introducción

El código que te mostraré aquí te servirá para averiguar la versión de un ensamblado, (o la de cualquier ejecutable o librería), aunque en esta ocasión veremos en concreto el ensamblado actual, es decir, el ensamblado (ejecutable o librería) en el que se encuentre el código aquí indicado.

Antes de nada te diré que la versión de los ensamblados de .NET se divide en cuatro partes: Mayor, Menor, Revisión y Build.
También verás que con la clase de .NET que usaremos para averiguar estos datos, también puedes obtener otra información además de la versión... pero... esa otra información tendrás que "averiguarla" por tu cuenta o bien esperar a que publique otro artículo en el que muestre el resto (o al menos las más interesantes), eso será en un módulo con las equivalencias (o casi) del objeto APP que se incluye con las versiones de Visual Basic clásico (VB6 y anteriores).

La clase que usaremos para averiguar la versión de un ensamblado será: FileVersionInfo.
Esta clase, como te he comentado antes, además de informarnos de la versión de un ejecutable o librería, también nos puede informar de los datos de copyright, comentarios, etc., es decir la información que normalmente nos muestra el Windows cuando seleccionamos Versión en las propiedades del ejecutable.

Para poder obtener una instancia de esa clase, podemos usar el miembro compartido GetVersionInfo de esa misma clase y una vez que la tengamos, podemos "desgranar" dicha información.

GetVersionInfo devuelve un objeto del tipo FileVersionInfo con la información del fichero que hayamos indicado, por tanto tendremos que decirle de que fichero tiene que darnos la información.
Antes de ver cómo obtendríamos la información del ensamblado actual (el que está en ejecución), vamos a ver cómo podríamos obtener la información, por ejemplo del Bloc de notas: (suponiendo que esté en C:\Windows)

System.Diagnostics.FileVersionInfo.GetVersionInfo("C:\Windows\Notepad.exe").FileVersion

En este caso he usado la propiedad FileVersion del objeto FileVersionInfo, el resultado devuelto por esa propiedad se puede asignar a una variable o mostrarla directamente, etc... aunque ahí sólo haya indicado la forma de usarla, se supone que sabes que debes hacer algo con el valor devuelto... que después me decís que eso da error... je, je.

Ahora lo que nos interesa es indicarle que la información que queremos obtener es del ejecutable que está en memoria, para ello tenemos que acudir al espacio de nombres Reflection, en el cual nos encontramos con la clase Assembly, la cual nos permitirá, entre otras cosas obtener el ensamblado que está en ejecución y a partir de esa información obtener el path del ejecutable.
Sí, son muchas vueltas, pero... al menos obtenemos lo que queremos, que es, al fin y al cabo, lo que nos interesa: saber el path del ejecutable para poder pasárselo como parámetro a la función GetVersionInfo.

Veamos el código para poder obtener el path del ejecutable actual, realmente del ejecutable entero, es decir, no sólo obtenemos el path, sino todo... incluido el nombre del ejecutable:

System.Reflection.Assembly.GetExecutingAssembly.Location

Una vez que sabemos cómo saber dónde está el ejecutable y sabemos cómo llamar a la clase que nos da la información de un ejecutable, podemos usar algunas de las propiedades de FileVersionInfo para saber los datos de la versión:

Para poder comprobar que todo funciona a las mil maravillas, vamos a crear un proyecto de consola con el cual imprimiremos la información del ensamblado que está en ejecución... y, sabiendo cómo funciona todo esto, no nos costará ningún trabajo modificarlo para que nos de información de cualquier ejecutable que le indiquemos...
Pero lo primero es lo primero, (después te podré el otro caso como ejercicio), así que vamos a ver el código para que nos muestre la versión del ejecutable en el que se encuentra este código:

Module Module1
    ' El ejecutable del que queremos obtener la información
    Private mLocation As String
    '
    Sub Main()
        ' Mostrar información del ejecutable actual
        mLocation = System.Reflection.Assembly.GetExecutingAssembly.Location
        '
        mostrarInfo()
        '
        Console.WriteLine()
        Console.WriteLine("Pulsa INTRO para terminar.")
        Console.ReadLine()
    End Sub
    '
    Private Sub mostrarInfo()
        Console.WriteLine("Información sobre la versión de: {0}", EXEName)
        Console.WriteLine("Versión: {0}", FileVersion)
        Console.WriteLine()
        Console.WriteLine("Mayor  : {0,5}", FileMajorPart)
        Console.WriteLine("Menor  : {0,5}", FileMinorPart)
        Console.WriteLine("Build  : {0,5}", FileBuildPart)
        Console.WriteLine("Private: {0,5}", FilePrivatePart)
    End Sub
    '
    '
    Private ReadOnly Property FileMajorPart() As Int32
        Get
            Return System.Diagnostics.FileVersionInfo.GetVersionInfo(mLocation).FileMajorPart
        End Get
    End Property
    Private ReadOnly Property FileMinorPart() As Int32
        Get
            Return System.Diagnostics.FileVersionInfo.GetVersionInfo(mLocation).FileMinorPart
        End Get
    End Property
    Private ReadOnly Property FileBuildPart() As Int32
        Get
            Return System.Diagnostics.FileVersionInfo.GetVersionInfo(mLocation).FileBuildPart
        End Get
    End Property
    Private ReadOnly Property FilePrivatePart() As Int32
        Get
            Return System.Diagnostics.FileVersionInfo.GetVersionInfo(mLocation).FilePrivatePart
        End Get
    End Property
    '
    Private ReadOnly Property FileVersion() As String
        Get
            Return System.Diagnostics.FileVersionInfo.GetVersionInfo(mLocation).FileVersion
        End Get
    End Property
    '
    Private ReadOnly Property EXEName() As String
        Get
            Return System.IO.Path.GetFileName(mLocation)
        End Get
    End Property
    '
End Module

Este código, (que una vez compilado he llamado FileVersionInfoVB.exe), mostraría lo siguiente:

Información sobre la versión de: FileVersionInfoVB.exe
Versión: 1.0.1356.35615

Mayor  :     1
Menor  :     0
Build  :  1356
Private: 35615

Pulsa INTRO para terminar.

Nota:
Puedes usar el siguiente link de la ayuda de Visual Studio .NET para saber todas las propiedades de FileVersionInfo:
ms-help://.../cpref/html/frlrfsystemdiagnosticsfileversioninfomemberstopic.htm

Ejercicio:

Ahora podrías cambiar o modificar el código anterior para que en la línea de comandos se le indique el ejecutable del que queremos mostrar la información y en caso de que no se indique ninguno, muestre la información del ejecutable actual.

Nota:
Si el nombre del ejecutable, el cual hay que indicar con el path completo, contiene espacios, habrá que indicarlo entrecomillado, si no tiene espacios no hace falta ponerlo entre comillas.

La solución la tienes un poco más abajo.

El código de C# para los dos proyectos también lo tienes más abajo... siguiendo este link.

Espero que te resulte útil.

Nos vemos.
Guillermo

Aquí tienes el código tanto para VB como para C#: appVersion.zip 9.85 KB

El código para VB .NET para el ejercicio propuesto.

Aunque aquí lo muestro como una clase (Class), se podría haber usado un módulo (Module).
Si quieres comprobarlo, (usando Module en lugar de Class), tendrás que quitar los Shared que indican que son miembros compartidos.

Si te fijas, "el truco" está en obtener de la línea de comandos el nombre del ejecutable del que queremos mostrar la información, cosa que se hace en el procedimiento Main, el resto es igual que el código mostrado anteriormente, salvo por la salvedad de que se ha usado una clase con miembros compartidos en lugar de un módulo, pero es que así lo tengo más fácil para convertirlo a C#.

Class Clase2
    ' El ejecutable del que queremos obtener la información
    Private Shared mLocation As String
    '
    Shared Sub Main(ByVal args() As String)
        ' Mostrar información del ejecutable indicado en la línea de comandos
        Dim i As Integer = args.Length
        '
        ' si no se ha indicado ningún parámetro, usar el ejecutable actual
        If i = 0 Then
            mLocation = System.Reflection.Assembly.GetExecutingAssembly.Location
        Else
            ' usar el indicado en el primer parámetro
            mLocation = args(0)
        End If
        '
        ' usar una captura de errores, por si el parámetro es erróneo
        Try
            mostrarInfo()
        Catch ex As Exception
            Console.WriteLine("ERROR: {0}", ex.Message)
        End Try
        '
        Console.WriteLine()
        Console.WriteLine("Pulsa INTRO para terminar.")
        Console.ReadLine()
    End Sub
    '
    Private Shared Sub mostrarInfo()
        Console.WriteLine("Información sobre la versión de: {0}", EXEName)
        Console.WriteLine("Versión: {0}", FileVersion)
        Console.WriteLine()
        Console.WriteLine("Mayor  : {0,5}", FileMajorPart)
        Console.WriteLine("Menor  : {0,5}", FileMinorPart)
        Console.WriteLine("Build  : {0,5}", FileBuildPart)
        Console.WriteLine("Private: {0,5}", FilePrivatePart)
    End Sub
    '
    '
    Private Shared ReadOnly Property FileMajorPart() As Int32
        Get
            Return System.Diagnostics.FileVersionInfo.GetVersionInfo(mLocation).FileMajorPart
        End Get
    End Property
    Private Shared ReadOnly Property FileMinorPart() As Int32
        Get
            Return System.Diagnostics.FileVersionInfo.GetVersionInfo(mLocation).FileMinorPart
        End Get
    End Property
    Private Shared ReadOnly Property FileBuildPart() As Int32
        Get
            Return System.Diagnostics.FileVersionInfo.GetVersionInfo(mLocation).FileBuildPart
        End Get
    End Property
    Private Shared ReadOnly Property FilePrivatePart() As Int32
        Get
            Return System.Diagnostics.FileVersionInfo.GetVersionInfo(mLocation).FilePrivatePart
        End Get
    End Property
    '
    Private Shared ReadOnly Property FileVersion() As String
        Get
            Return System.Diagnostics.FileVersionInfo.GetVersionInfo(mLocation).FileVersion
        End Get
    End Property
    '
    Private Shared ReadOnly Property EXEName() As String
        Get
            Return System.IO.Path.GetFileName(mLocation)
        End Get
    End Property
    '
End Class

El código de C# para obtener información del ejecutable actual:

namespace FileVersionInfoCS
{
    /// 
    /// Descripción breve de Class1.
    /// 
    class Class1
    {
        // El ejecutable del que queremos obtener la información
        private static string mLocation;
        //
        /// 
        /// Punto de entrada principal de la aplicación.
        /// 
        [STAThread]
        static void Main(string[] args)
        {
            //
            // TODO: agregar aquí código para iniciar la aplicación
            //
            // Mostrar información del ejecutable actual
            mLocation = System.Reflection.Assembly.GetExecutingAssembly().Location;
            //
            mostrarInfo();
            //
            Console.WriteLine();
            Console.WriteLine("Pulsa INTRO para terminar.");
            Console.ReadLine();
        }
        //
        private static void mostrarInfo()
        {
            Console.WriteLine("Información sobre la versión de: {0}", EXEName);
            Console.WriteLine("Versión: {0}", FileVersion);
            Console.WriteLine();
            Console.WriteLine("Mayor  : {0,5}", FileMajorPart);
            Console.WriteLine("Menor  : {0,5}", FileMinorPart);
            Console.WriteLine("Build  : {0,5}", FileBuildPart);
            Console.WriteLine("Private: {0,5}", FilePrivatePart);
        }  
        //
        //
        private static Int32 FileMajorPart
        {
            get
            {
                return System.Diagnostics.FileVersionInfo.GetVersionInfo(mLocation).FileMajorPart;
            }
        }  
        private static Int32 FileMinorPart
        {
            get
            {
                return System.Diagnostics.FileVersionInfo.GetVersionInfo(mLocation).FileMinorPart;
            }
        }  
        private static Int32 FileBuildPart
        {
            get
            {
                return System.Diagnostics.FileVersionInfo.GetVersionInfo(mLocation).FileBuildPart;
            }
        }  
        private static Int32 FilePrivatePart
        {
            get
            {
                return System.Diagnostics.FileVersionInfo.GetVersionInfo(mLocation).FilePrivatePart;
            }
        }  
        //
        private static string FileVersion
        {
            get
            {
                return System.Diagnostics.FileVersionInfo.GetVersionInfo(mLocation).FileVersion;
            }
        }  
        //
        private static string EXEName
        {
            get
            {
                return System.IO.Path.GetFileName(mLocation);
            }
        }  
    }
}

El código de C# para el ejercicio propuesto.

class Clase2
{
    // El ejecutable del que queremos obtener la información
    private static string mLocation;
    //
    static void Main(string[] args)
    {
        // Mostrar información del ejecutable indicado en la línea de comandos
        int i  = args.Length;
        //
        // si no se ha indicado ningún parámetro, usar el ejecutable actual
        if( i == 0 )
        {
            mLocation = System.Reflection.Assembly.GetExecutingAssembly().Location;
        }
        else
        {
            // usar el indicado en el primer parámetro
            mLocation = args[0];
        }
        //
        // usar una captura de errores, por si el parámetro es erróneo
        try
        {
            mostrarInfo();
        }
        catch(Exception ex )
        {
            Console.WriteLine("ERROR: {0}", ex.Message);
        }
        //
        Console.WriteLine();
        Console.WriteLine("Pulsa INTRO para terminar.");
        Console.ReadLine();
    }  
    //
    private static void mostrarInfo()
    {
        Console.WriteLine("Información sobre la versión de: {0}", EXEName);
        Console.WriteLine("Versión: {0}", FileVersion);
        Console.WriteLine();
        Console.WriteLine("Mayor  : {0,5}", FileMajorPart);
        Console.WriteLine("Menor  : {0,5}", FileMinorPart);
        Console.WriteLine("Build  : {0,5}", FileBuildPart);
        Console.WriteLine("Private: {0,5}", FilePrivatePart);
    }  
    //
    //
    private static Int32 FileMajorPart
    {
        get
        {
            return System.Diagnostics.FileVersionInfo.GetVersionInfo(mLocation).FileMajorPart;
        }
    }  
    private static Int32 FileMinorPart
    {
        get
        {
            return System.Diagnostics.FileVersionInfo.GetVersionInfo(mLocation).FileMinorPart;
        }
    }  
    private static Int32 FileBuildPart
    {
        get
        {
            return System.Diagnostics.FileVersionInfo.GetVersionInfo(mLocation).FileBuildPart;
        }
    }  
    private static Int32 FilePrivatePart
    {
        get
        {
            return System.Diagnostics.FileVersionInfo.GetVersionInfo(mLocation).FilePrivatePart;
        }
    }  
    //
    private static string FileVersion
    {
        get
        {
            return System.Diagnostics.FileVersionInfo.GetVersionInfo(mLocation).FileVersion;
        }
    }  
    //
    private static string EXEName
    {
        get
        {
            return System.IO.Path.GetFileName(mLocation);
        }
    }  
}

Saber la versión de un ejecutable (o ensamblado)

Introducción

Saber la versión de un ejecutable
(o ensamblado)