System.Version classe

Este artigo fornece observações complementares à documentação de referência para essa API.

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

maior.menor[.construir[.revisão]]

Os componentes são usados por 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 regravação importante de um produto em que a compatibilidade com versões anteriores não pode ser presumida.

• Menor: Se o nome e o número da versão principal em dois assemblies forem iguais, mas o número da versão secundária for diferente, isso indicará 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 uma versão pontual de um produto ou uma nova versão totalmente compatível com versões anteriores de um produto.

• Compilação: Uma diferença no número de compilação representa uma recompilação da mesma fonte. Números de compilação 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 principal e secundária, mas revisões diferentes, devem ser totalmente intercambiáveis. Um número de revisão mais alto pode ser usado em uma compilação que corrige uma falha de segurança em um assembly lançado anteriormente.

Versões subsequentes de um assembly que diferem apenas por números de compilação ou revisão são consideradas atualizações de Hotfix da versão anterior.

Importante

O valor das Version propriedades às quais não foi explicitamente atribuído um valor é indefinido (-1).

As MajorRevision propriedades e MinorRevision permitem que você identifique 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 assemblies

Normalmente, a classe não é usada para atribuir um número de versão a Version 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 sistema ou componente de 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 da versão do sistema operacional.

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

• 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 {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())
  

• Recuperando a versão de assembly do aplicativo atual. O exemplo a seguir usa o método para obter uma referência a um Assembly objeto que representa o Assembly.GetEntryAssembly executável do aplicativo e, em seguida, recupera seu 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 de assembly do assembly atual. O exemplo a seguir usa a propriedade para obter uma referência a Type.Assembly 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 objeto que tem um Assembly 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 Assembly objeto 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 propriedade para exibir a ApplicationDeployment.CurrentVersion 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 é manipulado 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: {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

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

Comparar objetos de versão

Você pode usar o CompareTo método para determinar se um objeto é anterior a, igual ou posterior a um Version 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 {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 duas versões sejam iguais, os números principal, secundário, de compilação e de revisão do primeiro Version objeto devem ser idênticos aos do segundo Version objeto. Se o número de compilação ou revisão de um objeto for indefinido, esse Version objeto será considerado anterior a um VersionVersion objeto cujo número de compilação ou revisão for 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 {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