Classe System.Version

Article
01/11/2024

Cet article vous offre des remarques complémentaires à la documentation de référence pour cette API.

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 secondaire supérieur peut indiquer une version point 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 assemblys portant le même nom, les numéros de version principale et secondaire, mais différentes révisions sont destinées à ê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é attribuées explicitement à une valeur n’est pas définie (-1).

MinorRevision Les MajorRevision propriétés vous permettent d’identifier une version temporaire de votre application qui corrige, par exemple, un problème jusqu’à ce que vous puissiez libérer 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.

Affecter des informations de version aux 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: {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())

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

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 d’assembly 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(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

Récupération de la version d’un assembly spécifique. L’exemple suivant utilise la Assembly.ReflectionOnlyLoadFrom méthode pour obtenir une référence à un Assembly objet qui a un nom de fichier particulier, puis récupère ses informations de version. Notez que plusieurs autres méthodes existent également pour instancier un Assembly objet par nom de fichier ou par nom fort.

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

Récupération de la version de publication d’une application ClickOnce. L’exemple suivant utilise la ApplicationDeployment.CurrentVersion propriété pour afficher la version de publication d’une application. Notez que son exécution réussie nécessite la définition de l’identité d’application de l’exemple. Cette opération est gérée automatiquement par l’Assistant Publication de 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
```
Important

La version de publication d’une application pour le déploiement ClickOnce est complètement indépendante de sa version d’assembly.

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 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.

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 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

Classe System.Version

Affecter des informations de version aux assemblys

Récupérer les informations de version

Comparer des objets de version

Commentaires

Ressources supplémentaires