Compartilhar via

Classe System.Version

Este artigo fornece comentários complementares à documentação de referência para esta API.

A Version classe representa o número de versão de um assembly, sistema operacional ou o common language runtime. Os números de versão consistem em dois a quatro componentes: versão principal, versão secundária, compilação e revisão. Os componentes principais e secundários são necessários; os componentes de build e revisão são opcionais, mas o componente de build é necessário se o componente de revisão for definido. Todos os componentes definidos devem ser inteiros maiores ou iguais a 0. O formato do número de versão é o seguinte (componentes opcionais são mostrados em colchetes):

principal. minor[.build[.revisão]]

Os componentes são usados pela convenção da seguinte maneira:

  • Principal: assemblies com o mesmo nome, mas versões principais diferentes não são intercambiáveis. Um número de versão mais alto pode indicar uma reescrita principal de um produto em que a compatibilidade com versões anteriores não pode ser assumida.

  • Secundária: se o nome e o número de versão principal em dois assemblies forem iguais, mas o número de versão secundária for diferente, isso indica um aprimoramento significativo com a intenção de compatibilidade com versões anteriores. Esse número de versão secundária mais alto pode indicar um lançamento pontual de um produto ou uma nova versão totalmente compatível com versões anteriores de um produto.

  • Build: uma diferença no número de build representa uma recompilação da mesma origem. Números de build diferentes podem ser usados quando o processador, a plataforma ou o compilador são alterados.

  • Revisão: assemblies com o mesmo nome, números de versão principais e secundários, mas revisões diferentes devem ser totalmente intercambiáveis. Um número de revisão mais alto pode ser usado em um build que corrige uma falha de segurança em um assembly lançado anteriormente.

As versões subsequentes de um assembly que diferem apenas por números de build ou revisão são consideradas atualizações de correção rápida da versão anterior.

Importante

O valor das Version propriedades que não foram explicitamente atribuídas a um valor é indefinido (-1).

As propriedades MajorRevision e MinorRevision permitem identificar uma versão temporária do seu aplicativo que, por exemplo, corrige um problema até que você possa liberar uma solução permanente. Além disso, o sistema operacional Windows NT usa a MajorRevision propriedade para codificar o número do service pack.

Atribuir informações de versão a conjuntos

Normalmente, a Version classe não é usada para atribuir um número de versão a um assembly. Em vez disso, a AssemblyVersionAttribute classe é usada para definir a versão de um assembly, conforme ilustrado pelo exemplo neste artigo.

Recuperar informações de versão

Version os objetos são usados com mais frequência para armazenar informações de versão sobre algum componente do sistema ou aplicativo (como o sistema operacional), o common language runtime, o executável do aplicativo atual ou um assembly específico. Os exemplos a seguir ilustram alguns dos cenários mais comuns:

  • Recuperando a versão do sistema operacional. O exemplo a seguir usa a OperatingSystem.Version propriedade para recuperar o número de versão do sistema operacional.

    // Get the operating system version.
OperatingSystem os = Environment.OSVersion;
Version ver = os.Version;
Console.WriteLine($"Operating System: {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())

  • Recuperando a versão do Common Language Runtime. O exemplo a seguir usa a Environment.Version propriedade para recuperar informações de versão sobre o common language runtime.

    // Get the common language runtime version.
Version ver = Environment.Version;
Console.WriteLine($"CLR Version {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())

  • Recuperando a versão do assembly do aplicativo atual. O exemplo a seguir usa o Assembly.GetEntryAssembly método para obter uma referência a um Assembly objeto que representa o executável do aplicativo e, em seguida, recupera o número de versão do assembly.

    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

  • Recuperando a versão do assembly atual. O exemplo a seguir usa a Type.Assembly propriedade para obter uma referência a um Assembly objeto que representa o assembly que contém o ponto de entrada do aplicativo e, em seguida, recupera suas informações de versão.

    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

  • Recuperando a versão de um assembly específico. O exemplo a seguir usa o Assembly.ReflectionOnlyLoadFrom método para obter uma referência a um Assembly objeto que tem um nome de arquivo específico e, em seguida, recupera suas informações de versão. Observe que vários outros métodos também existem para instanciar um objeto Assembly por nome de arquivo ou por nome forte.

    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

  • Recuperando a versão de publicação de um aplicativo ClickOnce. O exemplo a seguir usa a ApplicationDeployment.CurrentVersion propriedade para exibir a Versão de Publicação de um aplicativo. Observe que sua execução bem-sucedida requer que a identidade do aplicativo do exemplo seja definida. Isso é tratado automaticamente pelo Assistente de Publicação do Visual Studio.

    using System;
using System.Deployment.Application;

public class Example
{
   public static void Main()
   {
      Version ver = ApplicationDeployment.CurrentDeployment.CurrentVersion;
      Console.WriteLine($"ClickOnce Publish Version: {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

    A Versão de Publicação de um aplicativo para implantação do ClickOnce é completamente independente de sua versão do assembly.

Comparar objetos de versão

Você pode usar o CompareTo método para determinar se um Version objeto é anterior, o mesmo que ou posterior a um segundo Version objeto. O exemplo a seguir indica que a versão 2.1 é posterior à versão 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 {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 duas versões sejam iguais, os números principais, secundários, de build e de revisão do primeiro Version objeto devem ser idênticos aos do segundo Version objeto. Se o número de build ou revisão de um Version objeto for indefinido, esse Version objeto será considerado anterior a um Version objeto cujo número de build ou revisão seja igual a zero. O exemplo a seguir ilustra isso comparando três Version objetos que têm componentes de versão indefinidos.

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 {v1} to {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
  • Last updated on