Version Classe

Definição

public ref class Version sealed : IComparable, IComparable<Version ^>, IEquatable<Version ^>

public ref class Version sealed : ICloneable, IComparable, IComparable<Version ^>, IEquatable<Version ^>, ISpanFormattable, IUtf8SpanFormattable, IUtf8SpanParsable<Version ^>

public ref class Version sealed : ICloneable, IComparable, IComparable<Version ^>, IEquatable<Version ^>

public ref class Version sealed : ICloneable, IComparable, IComparable<Version ^>, IEquatable<Version ^>, ISpanFormattable

public ref class Version sealed : ICloneable, IComparable, IComparable<Version ^>, IEquatable<Version ^>, ISpanFormattable, IUtf8SpanFormattable

public ref class Version sealed : ICloneable, IComparable

public sealed class Version : IComparable, IComparable<Version>, IEquatable<Version>

public sealed class Version : ICloneable, IComparable, IComparable<Version>, IEquatable<Version>, ISpanFormattable, IUtf8SpanFormattable, IUtf8SpanParsable<Version>

public sealed class Version : ICloneable, IComparable, IComparable<Version>, IEquatable<Version>

public sealed class Version : ICloneable, IComparable, IComparable<Version>, IEquatable<Version>, ISpanFormattable

public sealed class Version : ICloneable, IComparable, IComparable<Version>, IEquatable<Version>, ISpanFormattable, IUtf8SpanFormattable

[System.Serializable]
public sealed class Version : ICloneable, IComparable

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Version : ICloneable, IComparable, IComparable<Version>, IEquatable<Version>

type Version = class
    interface IComparable
    interface IComparable<Version>
    interface IEquatable<Version>

type Version = class
    interface ICloneable
    interface IComparable
    interface IComparable<Version>
    interface IEquatable<Version>
    interface IFormattable
    interface ISpanFormattable
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<Version>

type Version = class
    interface ICloneable
    interface IComparable
    interface IComparable<Version>
    interface IEquatable<Version>

type Version = class
    interface ICloneable
    interface IComparable
    interface IComparable<Version>
    interface IEquatable<Version>
    interface ISpanFormattable
    interface IFormattable

type Version = class
    interface ICloneable
    interface IComparable
    interface IComparable<Version>
    interface IEquatable<Version>
    interface IFormattable
    interface ISpanFormattable

type Version = class
    interface ICloneable
    interface IComparable
    interface IComparable<Version>
    interface IEquatable<Version>
    interface IFormattable
    interface ISpanFormattable
    interface IUtf8SpanFormattable

type Version = class
    interface IComparable
    interface IComparable<Version>
    interface IEquatable<Version>
    interface ICloneable

[<System.Serializable>]
type Version = class
    interface ICloneable
    interface IComparable

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Version = class
    interface ICloneable
    interface IComparable
    interface IComparable<Version>
    interface IEquatable<Version>

Public NotInheritable Class Version
Implements IComparable, IComparable(Of Version), IEquatable(Of Version)

Public NotInheritable Class Version
Implements ICloneable, IComparable, IComparable(Of Version), IEquatable(Of Version), ISpanFormattable, IUtf8SpanFormattable, IUtf8SpanParsable(Of Version)

Public NotInheritable Class Version
Implements ICloneable, IComparable, IComparable(Of Version), IEquatable(Of Version)

Public NotInheritable Class Version
Implements ICloneable, IComparable, IComparable(Of Version), IEquatable(Of Version), ISpanFormattable

Public NotInheritable Class Version
Implements ICloneable, IComparable, IComparable(Of Version), IEquatable(Of Version), ISpanFormattable, IUtf8SpanFormattable

Public NotInheritable Class Version
Implements ICloneable, IComparable

Herança

Object

Version

Atributos

SerializableAttribute ComVisibleAttribute

Implementações

IComparable IComparable<Version> IEquatable<Version> ICloneable IFormattable ISpanFormattable IUtf8SpanFormattable IUtf8SpanParsable<Version>

Exemplos

O exemplo seguinte usa o AssemblyVersionAttribute atributo para atribuir um número de versão a uma assembleia. No momento da compilação, esta informação de versão é armazenada com os metadados do assembly. Em tempo de execução, o exemplo recupera o valor da Type.Assembly propriedade num tipo encontrado na montagem para obter uma referência à montagem em execução, e recupera a informação da versão da montagem a partir da Version propriedade do AssemblyName objeto devolvida pelo Assembly.GetName método.

using System;
using System.Reflection;

[assembly:AssemblyVersionAttribute("2.0.1")]

public class Example1
{
   public static void Main()
   {
      Assembly thisAssem = typeof(Example1).Assembly;
      AssemblyName thisAssemName = thisAssem.GetName();
       
      Version ver = thisAssemName.Version;
       
      Console.WriteLine("This is version {0} of {1}.", ver, thisAssemName.Name);    
   }
}

// The example displays the following output:
//        This is version 2.0.1.0 of Example1.

open System.Reflection

[<assembly: AssemblyVersionAttribute "2.0.1">]
do ()

type Example1 = class end

let thisAssem = typeof<Example1>.Assembly
let thisAssemName = thisAssem.GetName()
   
let ver = thisAssemName.Version
   
printfn $"This is version {ver} of {thisAssemName.Name}."
// The example displays the following output:
//        This is version 2.0.1.0 of Example1.

Imports System.Reflection

<Assembly:AssemblyVersionAttribute("2.0.1")>
Module MExample1
    Public Sub Main()
        Dim thisAssem As Assembly = Assembly.GetExecutingAssembly()
        Dim thisAssemName As AssemblyName = thisAssem.GetName()

        Dim ver As Version = thisAssemName.Version

        Console.WriteLine("This is version {0} of {1}.", ver, thisAssemName.Name)
    End Sub
End Module

' The example displays the following output:
'      This is version 2.0.1.0 of Example1.

Observações

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, menor, compilação e revisão. Os componentes principais e secundários 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 parênteses retos):

maior.menor[.compilação[.revisão]]

Os componentes são utilizados por convenção da seguinte forma:

• Major: Montagens com o mesmo nome, mas com versões principais diferentes, não são intercambiáveis. Um número de versão mais alto pode indicar uma grande reescrita de um produto onde 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 os mesmos, mas o número da versão secundária for diferente, isso indica um aprimoramento significativo com a intenção de retrocompatibilidade. 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 retroativamente de um produto.

• Build: 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: Conjuntos com o mesmo nome, mesmos números das versões principal e secundária, mas revisões diferentes, destinam-se a ser totalmente intercambiáveis. Um número de revisão maior pode ser usado em uma compilação que corrige uma falha de segurança em um assembly lançado anteriormente.

As versões subsequentes de um assembly que diferem apenas pelos números de compilação ou revisão são consideradas correções rápidas da versão precedente.

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 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 freqüência para armazenar informações de versão sobre algum sistema ou componente do 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: {os.VersionString} ({ver})");
  

  // 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}");
  

  // 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 compilação 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 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 da montagem 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(Example3).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 = Assembly.GetExecutingAssembly()
          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
  

Comparar objetos de versão

Você pode usar o CompareTo método para determinar se um Version objeto é anterior a, igual 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(2, 0);
Version v2 = new("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, menores, 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 Version objeto for indefinido, esse Version objeto será considerado anterior a um Version objeto cujo número de compilação ou revisão é 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(1, 1);
      Version v1a = new("1.1.0");
      ShowRelationship(v1, v1a);
      
      Version v1b = new(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