System.Version-klasse

De Version-klasse vertegenwoordigt het versienummer van een assembly, besturingssysteem of de algemene taalruntime. Versienummers bestaan uit twee tot vier onderdelen: primaire, secundaire versie, build en revisie. De belangrijkste en secundaire onderdelen zijn vereist; de build- en revisieonderdelen zijn optioneel, maar het buildonderdeel is vereist als het revisieonderdeel is gedefinieerd. Alle gedefinieerde onderdelen moeten gehele getallen groter dan of gelijk aan 0 zijn. De notatie van het versienummer is als volgt (optionele onderdelen worden weergegeven tussen vierkante haken):

primaire.secundaire[.build[.revisie]]

De onderdelen worden als volgt gebruikt volgens de conventie:

• Hoofd: Assemblies met dezelfde naam, maar verschillende hoofdversies zijn niet uitwisselbaar. Een hoger versienummer kan duiden op een belangrijk herschrijven van een product waarbij compatibiliteit met eerdere versies niet kan worden aangenomen.

• secundaire: als de naam en het primaire versienummer op twee assembly's hetzelfde zijn, maar het secundaire versienummer verschilt, betekent dit een aanzienlijke verbetering met de bedoeling van compatibiliteit met eerdere versies. Dit hogere secundaire versienummer kan duiden op een puntrelease van een product of een volledig achterwaarts compatibele nieuwe versie van een product.

• Build: een verschil in buildnummer vertegenwoordigt een hercompilatie van dezelfde bron. Er kunnen verschillende buildnummers worden gebruikt wanneer de processor, het platform of de compiler wordt gewijzigd.

• Revisie: Assemblies met dezelfde naam, hoofd- en onderversienummers, maar verschillende revisies, zijn bedoeld volledig uitwisselbaar te zijn. Een hoger revisienummer kan worden gebruikt in een build waarmee een beveiligingsgat in een eerder uitgebrachte assembly wordt opgelost.

Volgende versies van een assembly die alleen verschillen per build- of revisienummers, worden beschouwd als hotfix-updates van de vorige versie.

Met de eigenschappen MajorRevision en MinorRevision kunt u een tijdelijke versie van uw toepassing identificeren waarmee u bijvoorbeeld een probleem kunt oplossen totdat u een permanente oplossing kunt vrijgeven. Bovendien gebruikt het Windows NT-besturingssysteem de eigenschap MajorRevision om het servicepacknummer te coderen.

Versiegegevens toekennen aan assemblies

Normaal gesproken wordt de Version-klasse niet gebruikt om een versienummer toe te wijzen aan een assembly. In plaats daarvan wordt de klasse AssemblyVersionAttribute gebruikt om de versie van een assembly te definiëren, zoals wordt geïllustreerd in het voorbeeld in dit artikel.

Versiegegevens ophalen

Version objecten worden meestal gebruikt voor het opslaan van versie-informatie over een bepaald systeem of toepassingsonderdeel (zoals het besturingssysteem), de algemene taalruntime, het uitvoerbare bestand van de huidige toepassing of een bepaalde assembly. In de volgende voorbeelden ziet u enkele van de meest voorkomende scenario's:

• De versie van het besturingssysteem ophalen. In het volgende voorbeeld wordt de eigenschap OperatingSystem.Version gebruikt om het versienummer van het besturingssysteem op te halen.

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

• De versie van de algemene taalruntime ophalen. In het volgende voorbeeld wordt de eigenschap Environment.Version gebruikt om versie-informatie over de algemene taalruntime op te halen.

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

• De assemblyversie van de huidige toepassing ophalen. In het volgende voorbeeld wordt de methode Assembly.GetEntryAssembly gebruikt om een verwijzing te verkrijgen naar een Assembly-object dat het uitvoerbare bestand van de toepassing vertegenwoordigt en vervolgens het versienummer van de assembly ophaalt.

  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
  

• De assemblyversie van de huidige assembly ophalen. In het volgende voorbeeld wordt de eigenschap Type.Assembly gebruikt om een verwijzing te verkrijgen naar een Assembly-object dat de assembly vertegenwoordigt die het toepassingsinvoerpunt bevat en vervolgens de versie-informatie ophaalt.

  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
  

• De versie van een specifieke assembly ophalen. In het volgende voorbeeld wordt de methode Assembly.ReflectionOnlyLoadFrom gebruikt om een verwijzing naar een Assembly-object met een bepaalde bestandsnaam te verkrijgen en vervolgens de versiegegevens op te halen. Er bestaan ook verschillende andere methoden om een Assembly-object te instantiëren op bestandsnaam of op sterke naam.

  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
  

• De publicatieversie van een ClickOnce-toepassing ophalen. In het volgende voorbeeld wordt de eigenschap ApplicationDeployment.CurrentVersion gebruikt om de publicatieversie van een toepassing weer te geven. Houd er rekening mee dat de geslaagde uitvoering vereist dat de toepassingsidentiteit van het voorbeeld wordt ingesteld. Dit wordt automatisch afgehandeld door de wizard Publiceren van 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
  

  Belangrijk

  De publicatieversie van een toepassing voor ClickOnce-implementatie is volledig onafhankelijk van de assemblyversie.

Versieobjecten vergelijken

U kunt de methode CompareTo gebruiken om te bepalen of een Version object eerder is dan, hetzelfde als of later dan een tweede Version-object. In het volgende voorbeeld wordt aangegeven dat versie 2.1 nieuwer is dan versie 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.

Opdat twee versies gelijk zijn, moeten de primaire, secundaire, build- en revisienummers van het eerste Version-object identiek zijn aan die van het tweede Version-object. Als het build- of revisienummer van een Version-object niet is gedefinieerd, wordt dat Version object beschouwd als eerder dan een Version object waarvan het build- of revisienummer gelijk is aan nul. In het volgende voorbeeld ziet u dit door drie Version objecten te vergelijken met niet-gedefinieerde versieonderdelen.

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