Clase System.Version

Artículo
01/11/2024

En este artículo se proporcionan comentarios adicionales a la documentación de referencia de esta API.

La Version clase representa el número de versión de un ensamblado, un sistema operativo o Common Language Runtime. Los números de versión constan de dos a cuatro componentes: principal, secundario, compilación y revisión. Se requieren los componentes principales y secundarios; Los componentes de compilación y revisión son opcionales, pero el componente de compilación es necesario si se define el componente de revisión. Todos los componentes definidos deben ser enteros mayores o iguales que 0. El formato del número de versión es el siguiente (los componentes opcionales se muestran entre corchetes):

major.minor[.build[.revision]]

Los componentes se usan por convención de la siguiente manera:

Principal: los ensamblados con el mismo nombre, pero las distintas versiones principales no son intercambiables. Un número de versión superior podría indicar una reescritura principal de un producto en el que no se puede asumir la compatibilidad con versiones anteriores.
Menor: si el nombre y el número de versión principal en dos ensamblados son los mismos, pero el número de versión secundaria es diferente, esto indica una mejora significativa con la intención de la compatibilidad con versiones anteriores. Este número de versión secundaria superior podría indicar una versión puntual de un producto o una nueva versión totalmente compatible con versiones anteriores de un producto.
Compilación: una diferencia en el número de compilación representa una recompilación del mismo origen. Es posible que se usen números de compilación diferentes cuando cambia el procesador, la plataforma o el compilador.
Revisión: los ensamblados con el mismo nombre, los números de versión principal y secundaria, pero las revisiones diferentes están diseñadas para ser totalmente intercambiables. Es posible que se use un número de revisión mayor en una compilación que corrija un agujero de seguridad en un ensamblado liberado previamente.

Las versiones posteriores de un ensamblado que solo difieren en los números de compilación o revisión se consideran actualizaciones de revisiones de la versión anterior.

Importante

El valor de Version las propiedades que no se han asignado explícitamente a un valor es indefinido (-1).

Las MajorRevision propiedades y MinorRevision permiten identificar una versión temporal de la aplicación que, por ejemplo, corrige un problema hasta que pueda liberar una solución permanente. Además, el sistema operativo Windows NT usa la MajorRevision propiedad para codificar el número del Service Pack.

Asignación de información de versión a ensamblados

Normalmente, la Version clase no se usa para asignar un número de versión a un ensamblado. En su lugar, la clase se usa para definir la AssemblyVersionAttribute versión de un ensamblado, como se muestra en el ejemplo de este artículo.

Recuperar información de versión

Version Los objetos se usan con más frecuencia para almacenar información de versión sobre algún componente del sistema o de la aplicación (como el sistema operativo), Common Language Runtime, el ejecutable de la aplicación actual o un ensamblado determinado. En los ejemplos siguientes se muestran algunos de los escenarios más comunes:

Recuperar la versión del sistema operativo. En el ejemplo siguiente se usa la OperatingSystem.Version propiedad para recuperar el número de versión del sistema operativo.

// Get the operating system version.
OperatingSystem os = Environment.OSVersion;
Version ver = os.Version;
Console.WriteLine("Operating System: {0} ({1})", os.VersionString, ver.ToString());

// Get the operating system version.
let os = Environment.OSVersion
let ver = os.Version
printfn $"Operating System: {os.VersionString} ({ver})"

' Get the operating system version.
Dim os As OperatingSystem = Environment.OSVersion
Dim ver As Version = os.Version
Console.WriteLine("Operating System: {0} ({1})", os.VersionString, ver.ToString())

Recuperación de la versión de Common Language Runtime. En el ejemplo siguiente se usa la Environment.Version propiedad para recuperar información de versión sobre Common Language Runtime.

// Get the common language runtime version.
Version ver = Environment.Version;
Console.WriteLine("CLR Version {0}", ver.ToString());

// Get the common language runtime version.
let ver = Environment.Version
printfn $"CLR Version {ver}"

' Get the common language runtime version.
Dim ver As Version = Environment.Version
Console.WriteLine("CLR Version {0}", ver.ToString())

Recuperar la versión del ensamblado de la aplicación actual. En el ejemplo siguiente se usa el Assembly.GetEntryAssembly método para obtener una referencia a un Assembly objeto que representa el ejecutable de la aplicación y, a continuación, recupera su número de versión de ensamblado.

using System;
using System.Reflection;

public class Example4
{
   public static void Main()
   {
      // Get the version of the executing assembly (that is, this assembly).
      Assembly assem = Assembly.GetEntryAssembly();
      AssemblyName assemName = assem.GetName();
      Version ver = assemName.Version;
      Console.WriteLine("Application {0}, Version {1}", assemName.Name, ver.ToString());
   }
}

open System.Reflection

// Get the version of the executing assembly (that is, this assembly).
let assem = Assembly.GetEntryAssembly()
let assemName = assem.GetName()
let ver = assemName.Version
printfn $"Application {assemName.Name}, Version {ver}"

Imports System.Reflection

Module Example3
    Public Sub Main()
        ' Get the version of the executing assembly (that is, this assembly).
        Dim assem As Assembly = Assembly.GetEntryAssembly()
        Dim assemName As AssemblyName = assem.GetName()
        Dim ver As Version = assemName.Version
        Console.WriteLine("Application {0}, Version {1}", assemName.Name, ver.ToString())
    End Sub
End Module

Recuperar la versión del ensamblado actual. En el ejemplo siguiente se usa la Type.Assembly propiedad para obtener una referencia a un Assembly objeto que representa el ensamblado que contiene el punto de entrada de la aplicación y, a continuación, recupera su información de versión.

using System;
using System.Reflection;

public class Example3
{
   public static void Main()
   {
      // Get the version of the current assembly.
      Assembly assem = typeof(Example).Assembly;
      AssemblyName assemName = assem.GetName();
      Version ver = assemName.Version;
      Console.WriteLine("{0}, Version {1}", assemName.Name, ver.ToString());
   }
}

type Example = class end

// Get the version of the current assembly.
let assem = typeof<Example>.Assembly
let assemName = assem.GetName()
let ver = assemName.Version
printfn $"{assemName.Name}, Version {ver}"

Imports System.Reflection

Module Example1
    Public Sub Main()
        ' Get the version of the current assembly.
        Dim assem As Assembly = GetType(Example).Assembly
        Dim assemName As AssemblyName = assem.GetName()
        Dim ver As Version = assemName.Version
        Console.WriteLine("{0}, Version {1}", assemName.Name, ver.ToString())
    End Sub
End Module

Recuperar la versión de un ensamblado específico. En el ejemplo siguiente se usa el Assembly.ReflectionOnlyLoadFrom método para obtener una referencia a un Assembly objeto que tiene un nombre de archivo determinado y, a continuación, se recupera su información de versión. Tenga en cuenta que también existen otros métodos para crear instancias de un Assembly objeto por nombre de archivo o por nombre seguro.

using System;
using System.Reflection;

public class Example5
{
   public static void Main()
   {
      // Get the version of a specific assembly.
      string filename = @".\StringLibrary.dll";
      Assembly assem = Assembly.ReflectionOnlyLoadFrom(filename);
      AssemblyName assemName = assem.GetName();
      Version ver = assemName.Version;
      Console.WriteLine("{0}, Version {1}", assemName.Name, ver.ToString());
   }
}

open System.Reflection

// Get the version of a specific assembly.
let filename = @".\StringLibrary.dll"
let assem = Assembly.ReflectionOnlyLoadFrom filename
let assemName = assem.GetName()
let ver = assemName.Version
printfn $"{assemName.Name}, Version {ver}"

Imports System.Reflection

Module Example4
    Public Sub Main()
        ' Get the version of a specific assembly.
        Dim filename As String = ".\StringLibrary.dll"
        Dim assem As Assembly = Assembly.ReflectionOnlyLoadFrom(filename)
        Dim assemName As AssemblyName = assem.GetName()
        Dim ver As Version = assemName.Version
        Console.WriteLine("{0}, Version {1}", assemName.Name, ver.ToString())
    End Sub
End Module

Recuperar la versión de publicación de una aplicación ClickOnce. En el ejemplo siguiente se usa la propiedad para mostrar la ApplicationDeployment.CurrentVersion versión de publicación de una aplicación. Tenga en cuenta que su ejecución correcta requiere que se establezca la identidad de aplicación del ejemplo. El Asistente para publicación de Visual Studio controla esto automáticamente.
```
using System;
using System.Deployment.Application;

public class Example
{
   public static void Main()
   {
      Version ver = ApplicationDeployment.CurrentDeployment.CurrentVersion;
      Console.WriteLine("ClickOnce Publish Version: {0}", ver);
   }
}
```
```
Imports System.Deployment.Application

Module Example0
    Public Sub Main()
        Dim ver As Version = ApplicationDeployment.CurrentDeployment.CurrentVersion
        Console.WriteLine("ClickOnce Publish Version: {0}", ver)
    End Sub
End Module
```
Importante

La versión de publicación de una aplicación para la implementación de ClickOnce es completamente independiente de su versión de ensamblado.

Comparación de objetos de versión

Puede usar el CompareTo método para determinar si un Version objeto es anterior a, igual que o posterior a un segundo Version objeto. En el ejemplo siguiente se indica que la versión 2.1 es posterior a la versión 2.0.

Version v1 = new Version(2, 0);
Version v2 = new Version("2.1");
Console.Write("Version {0} is ", v1);
switch(v1.CompareTo(v2))
{
   case 0:
      Console.Write("the same as");
      break;
   case 1:
      Console.Write("later than");
      break;
   case -1:
      Console.Write("earlier than");
      break;
}
Console.WriteLine(" Version {0}.", v2);                  
// The example displays the following output:
//       Version 2.0 is earlier than Version 2.1.

open System

let v1 = Version(2, 0)
let v2 = Version "2.1"

printf $"Version {v1} is "

match v1.CompareTo v2 with
| 0 -> printf "the same as"
| 1 -> printf "later than"
| _ -> printf "earlier than"

printf $" Version {v2}."
// The example displays the following output:
//       Version 2.0 is earlier than Version 2.1.

Dim v1 As New Version(2,0)
Dim v2 As New Version("2.1")
Console.Write("Version {0} is ", v1)
Select Case v1.CompareTo(v2)
   Case 0
      Console.Write("the same as")
   Case 1
      Console.Write("later than")
   Case -1
      Console.Write("earlier than")
End Select
Console.WriteLine(" Version {0}.", v2)                  
' The example displays the following output:
'       Version 2.0 is earlier than Version 2.1.

Para que dos versiones sean iguales, los números principales, secundarios, de compilación y de revisión del primer Version objeto deben ser idénticos a los del segundo Version objeto. Si el número de compilación o revisión de un Version objeto no está definido, ese Version objeto se considera anterior a un Version objeto cuyo número de compilación o revisión es igual a cero. En el ejemplo siguiente se muestra esto comparando tres Version objetos que tienen componentes de versión no definidos.

using System;

enum VersionTime {Earlier = -1, Same = 0, Later = 1 };

public class Example2
{
   public static void Main()
   {
      Version v1 = new Version(1, 1);
      Version v1a = new Version("1.1.0");
      ShowRelationship(v1, v1a);
      
      Version v1b = new Version(1, 1, 0, 0);
      ShowRelationship(v1b, v1a);
   }

   private static void ShowRelationship(Version v1, Version v2)
   {
      Console.WriteLine("Relationship of {0} to {1}: {2}", 
                        v1, v2, (VersionTime) v1.CompareTo(v2));       
   }
}
// The example displays the following output:
//       Relationship of 1.1 to 1.1.0: Earlier
//       Relationship of 1.1.0.0 to 1.1.0: Later

open System

type VersionTime =
    | Earlier = -1
    | Same = 0
    | Later = 1

let showRelationship (v1: Version) (v2: Version) =
    printfn $"Relationship of {v1} to {v2}: {v1.CompareTo v2 |> enum<VersionTime>}" 

let v1 = Version(1, 1)
let v1a = Version "1.1.0"
showRelationship v1 v1a

let v1b = Version(1, 1, 0, 0)
showRelationship v1b v1a

// The example displays the following output:
//       Relationship of 1.1 to 1.1.0: Earlier
//       Relationship of 1.1.0.0 to 1.1.0: Later

Public Enum VersionTime
   Earlier = -1
   Same = 0
   Later = 1
End Enum

Module Example2
    Public Sub Main()
        Dim v1 As New Version(1, 1)
        Dim v1a As New Version("1.1.0")
        ShowRelationship(v1, v1a)

        Dim v1b As New Version(1, 1, 0, 0)
        ShowRelationship(v1b, v1a)
    End Sub

    Private Sub ShowRelationship(v1 As Version, v2 As Version)
        Console.WriteLine("Relationship of {0} to {1}: {2}",
                        v1, v2, CType(v1.CompareTo(v2), VersionTime))
    End Sub
End Module
' The example displays the following output:
'       Relationship of 1.1 to 1.1.0: Earlier
'       Relationship of 1.1.0.0 to 1.1.0: Later

Compartir a través de

Clase System.Version

Asignación de información de versión a ensamblados

Recuperar información de versión

Comparación de objetos de versión

Recursos adicionales