Version Classe

Définition

Espace de noms:

System

Assemblys:

netstandard.dll, System.Runtime.dll

Source:

Version.cs

Représente le numéro de version d’un assembly, d’un système d’exploitation ou du Common Language Runtime. Cette classe ne peut pas être héritée.

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

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

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

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

Héritage

Object

Version

Implémente

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

Exemples

L’exemple suivant utilise l’attribut AssemblyVersionAttribute pour affecter un numéro de version à un assembly. Au moment de la compilation, ces informations de version sont stockées avec les métadonnées de l’assembly. Au moment de l’exécution, l’exemple récupère la valeur de la Type.Assembly propriété sur un type trouvé dans l’assembly pour obtenir une référence à l’assembly en cours d’exécution et récupère les informations de version de l’assembly à partir de la Version propriété de l’objet AssemblyName retourné par la Assembly.GetName méthode.

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.

Remarques

La Version classe représente le numéro de version d’un assembly, d’un système d’exploitation ou du Common Language Runtime. Les numéros de version se composent de deux à quatre composants : majeur, mineur, build et révision. Les composants principaux et secondaires sont requis ; les composants de build et de révision sont facultatifs, mais le composant de build est requis si le composant de révision est défini. Tous les composants définis doivent être des entiers supérieurs ou égaux à 0. Le format du numéro de version est le suivant (les composants facultatifs sont affichés entre crochets) :

major. mineur[.build[.révision]]

Les composants sont utilisés par convention comme suit :

• Major : les assemblys portant le même nom, mais les différentes versions principales ne sont pas interchangeables. Un numéro de version plus élevé peut indiquer une réécriture majeure d’un produit où la compatibilité descendante ne peut pas être supposée.

• Mineur : si le nom et le numéro de version principale sur deux assemblys sont identiques, mais que le numéro de version secondaire est différent, cela indique une amélioration significative avec l’intention de compatibilité descendante. Ce numéro de version mineure plus élevé peut indiquer une version intermédiaire d’un produit ou une nouvelle version entièrement rétrocompatible d’un produit.

• Build : une différence dans le numéro de build représente une recompilation de la même source. Différents numéros de build peuvent être utilisés lorsque le processeur, la plateforme ou le compilateur change.

• Révision : les assemblages portant le même nom, numéro de version majeur et mineur, mais des révisions différentes, sont destinés à être entièrement interchangeables. Un numéro de révision plus élevé peut être utilisé dans une build qui corrige un trou de sécurité dans un assembly précédemment libéré.

Les versions ultérieures d’un assembly qui diffèrent uniquement par les numéros de build ou de révision sont considérées comme des mises à jour de correctif logiciel de la version précédente.

Important

La valeur des Version propriétés qui n’ont pas été explicitement affectées à une valeur n’est pas définie (-1).

Les propriétés MajorRevision et MinorRevision vous permettent d'identifier une version temporaire de votre application qui corrige, par exemple, un problème jusqu'à ce que vous puissiez déployer une solution permanente. En outre, le système d’exploitation Windows NT utilise la MajorRevision propriété pour encoder le numéro de Service Pack.

Assignez des informations de version à des assemblys

En règle générale, la Version classe n’est pas utilisée pour affecter un numéro de version à un assembly. Au lieu de cela, la AssemblyVersionAttribute classe est utilisée pour définir la version d’un assembly, comme illustré par l’exemple de cet article.

Récupérer les informations de version

Version les objets sont les plus fréquemment utilisés pour stocker des informations de version sur certains composants système ou d’application (tels que le système d’exploitation), le Common Language Runtime, l’exécutable de l’application actuelle ou un assembly particulier. Les exemples suivants illustrent certains des scénarios les plus courants :

• Récupération de la version du système d’exploitation. L’exemple suivant utilise la OperatingSystem.Version propriété pour récupérer le numéro de version du système d’exploitation.

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

• Récupération de la version du Common Language Runtime. L’exemple suivant utilise la Environment.Version propriété pour récupérer des informations de version sur le 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())
  

• Récupération de la version d’assembly de l’application actuelle. L’exemple suivant utilise la Assembly.GetEntryAssembly méthode pour obtenir une référence à un Assembly objet qui représente l’exécutable de l’application, puis récupère son numéro de version d’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
  

• Récupération de la version actuelle de l’assembly. L’exemple suivant utilise la Type.Assembly propriété pour obtenir une référence à un Assembly objet qui représente l’assembly qui contient le point d’entrée de l’application, puis récupère ses informations de version.

  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
  

Comparer des objets de version

Vous pouvez utiliser la CompareTo méthode pour déterminer si un Version objet est antérieur à, identique ou supérieur à un deuxième Version objet. L’exemple suivant indique que la version 2.1 est ultérieure à la version 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.

Pour que deux versions soient égales, les numéros principaux, mineurs, de build et de révision du premier Version objet doivent être identiques à ceux du deuxième Version objet. Si le numéro de build ou de révision d’un Version objet n’est pas défini, cet Version objet est considéré comme antérieur à un Version objet dont le numéro de build ou de révision est égal à zéro. L’exemple suivant illustre cela en comparant trois Version objets qui ont des composants de version non définis.

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

Constructeurs

Nom	Description
Version()	Initialise une nouvelle instance de la classe Version.
Version(Int32, Int32, Int32, Int32)	Initialise une nouvelle instance de la Version classe avec les numéros principaux, mineurs, de build et de révision spécifiés.
Version(Int32, Int32, Int32)	Initialise une nouvelle instance de la Version classe à l’aide des valeurs principales, mineures et de build spécifiées.
Version(Int32, Int32)	Initialise une nouvelle instance de la Version classe à l’aide des valeurs principales et mineures spécifiées.
Version(String)	Initialise une nouvelle instance de la classe à l’aide Version de la chaîne spécifiée.

Propriétés

Nom	Description
Build	Obtient la valeur du composant de build du numéro de version de l’objet actuel Version .
Major	Obtient la valeur du composant principal du numéro de version de l’objet actuel Version .
MajorRevision	Obtient les 16 bits élevés du numéro de révision.
Minor	Obtient la valeur du composant secondaire du numéro de version de l’objet actif Version .
MinorRevision	Obtient les 16 bits inférieurs du numéro de révision.
Revision	Obtient la valeur du composant de révision du numéro de version de l’objet actuel Version .

Méthodes

Nom	Description
Clone()	Retourne un nouvel Version objet dont la valeur est identique à l’objet actuel Version .
CompareTo(Object)	Compare l’objet actuel Version à un objet spécifié et retourne une indication de leurs valeurs relatives.
CompareTo(Version)	Compare l’objet actuel Version à un objet spécifié Version et retourne une indication de leurs valeurs relatives.
Equals(Object)	Retourne une valeur indiquant si l’objet actuel Version est égal à un objet spécifié.
Equals(Version)	Retourne une valeur indiquant si l’objet actuel Version et un objet spécifié Version représentent la même valeur.
GetHashCode()	Retourne un code de hachage pour l’objet actif Version .
GetType()	Obtient la Type de l’instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
Parse(ReadOnlySpan<Byte>)	Convertit l’étendue en lecture seule spécifiée de caractères UTF-8 qui représente un numéro de version en objet Version équivalent.
Parse(ReadOnlySpan<Char>)	Convertit l’étendue de caractères en lecture seule spécifiée qui représente un numéro de version en objet équivalent Version .
Parse(String)	Convertit la représentation sous forme de chaîne d’un numéro de version en objet équivalent Version .
ToString()	Convertit la valeur de l’objet actuel Version en sa représentation équivalente String .
ToString(Int32)	Convertit la valeur de l’objet actuel Version en sa représentation équivalente String . Un nombre spécifié indique le nombre de composants à retourner.
TryFormat(Span<Byte>, Int32, Int32)	Tente de mettre en forme cette instance de version en une étendue d’octets.
TryFormat(Span<Byte>, Int32)	Tente de mettre en forme cette instance de version en une étendue d’octets.
TryFormat(Span<Char>, Int32, Int32)	Tente de mettre en forme cette instance de version en une étendue de caractères.
TryFormat(Span<Char>, Int32)	Tente de mettre en forme cette instance de version en une étendue de caractères.
TryParse(ReadOnlySpan<Byte>, Version)	Tente de convertir la représentation UTF-8 d’un numéro de version en objet Version équivalent et retourne une valeur qui indique si la conversion a réussi.
TryParse(ReadOnlySpan<Char>, Version)	Tente de convertir l’étendue de caractères en lecture seule spécifiée représentant un numéro de version en objet équivalent Version et retourne une valeur qui indique si la conversion a réussi.
TryParse(String, Version)	Tente de convertir la représentation sous forme de chaîne d’un numéro de version en objet équivalent Version et retourne une valeur qui indique si la conversion a réussi.

Opérateurs

Nom	Description
Equality(Version, Version)	Détermine si deux objets spécifiés Version sont égaux.
GreaterThan(Version, Version)	Détermine si le premier objet spécifié Version est supérieur au deuxième objet spécifié Version .
GreaterThanOrEqual(Version, Version)	Détermine si le premier objet spécifié Version est supérieur ou égal au deuxième objet spécifié Version .
Inequality(Version, Version)	Détermine si deux objets spécifiés Version ne sont pas égaux.
LessThan(Version, Version)	Détermine si le premier objet spécifié Version est inférieur au deuxième objet spécifié Version .
LessThanOrEqual(Version, Version)	Détermine si le premier objet spécifié Version est inférieur ou égal au deuxième Version objet.

Implémentations d’interfaces explicites

Nom	Description
IFormattable.ToString(String, IFormatProvider)	Met en forme la valeur de l’instance actuelle à l’aide du format spécifié.
ISpanFormattable.TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tente de mettre en forme la valeur de l’instance actuelle dans l’étendue fournie de caractères.
IUtf8SpanFormattable.TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Tente de mettre en forme la valeur de l’instance actuelle en UTF-8 dans l’étendue fournie d’octets.
IUtf8SpanParsable<Version>.Parse(ReadOnlySpan<Byte>, IFormatProvider)	Représente le numéro de version d’un assembly, d’un système d’exploitation ou du Common Language Runtime. Cette classe ne peut pas être héritée.
IUtf8SpanParsable<Version>.TryParse(ReadOnlySpan<Byte>, IFormatProvider, Version)	Représente le numéro de version d’un assembly, d’un système d’exploitation ou du Common Language Runtime. Cette classe ne peut pas être héritée.