Classe System.Version

  • Articolo

Questo articolo fornisce osservazioni supplementari alla documentazione di riferimento per questa API.

La Version classe rappresenta il numero di versione di un assembly, di un sistema operativo o di Common Language Runtime. I numeri di versione sono costituiti da due a quattro componenti: principale, secondario, build e revisione. Sono necessari i componenti principali e secondari; i componenti di compilazione e revisione sono facoltativi, ma il componente di compilazione è obbligatorio se il componente di revisione è definito. Tutti i componenti definiti devono essere numeri interi maggiori o uguali a 0. Il formato del numero di versione è il seguente (i componenti facoltativi sono visualizzati tra parentesi quadre):

maggiore.minor[.build[.revisione]]

I componenti vengono usati per convenzione come segue:

  • Principale: gli assembly con lo stesso nome ma versioni principali diverse non sono intercambiabili. Un numero di versione superiore potrebbe indicare una riscrittura principale di un prodotto in cui non è possibile presumere la compatibilità con le versioni precedenti.

  • Secondaria: se il nome e il numero di versione principale in due assembly sono uguali, ma il numero di versione secondaria è diverso, questo indica un miglioramento significativo con l'intenzione di compatibilità con le versioni precedenti. Questo numero di versione secondaria superiore potrebbe indicare una versione punto di un prodotto o una nuova versione completamente compatibile con le versioni precedenti di un prodotto.

  • Build: una differenza nel numero di build rappresenta una ricompilazione della stessa origine. È possibile usare numeri di compilazione diversi quando il processore, la piattaforma o il compilatore cambia.

  • Revisione: gli assembly con lo stesso nome, numero di versione principale e secondaria, ma revisioni diverse devono essere completamente intercambiabili. Un numero di revisione superiore potrebbe essere usato in una compilazione che corregge un foro di sicurezza in un assembly rilasciato in precedenza.

Le versioni successive di un assembly che differiscono solo per i numeri di compilazione o revisione vengono considerate aggiornamenti rapidi della versione precedente.

Importante

Il valore delle Version proprietà a cui non è stato assegnato in modo esplicito un valore non è definito (-1).

Le MajorRevision proprietà e MinorRevision consentono di identificare una versione temporanea dell'applicazione che, ad esempio, corregge un problema fino a quando non è possibile rilasciare una soluzione permanente. Inoltre, il sistema operativo Windows NT usa la MajorRevision proprietà per codificare il numero del Service Pack.

Assegnare informazioni sulla versione agli assembly

In genere, la Version classe non viene usata per assegnare un numero di versione a un assembly. La classe viene invece usata per definire la AssemblyVersionAttribute versione di un assembly, come illustrato nell'esempio in questo articolo.

Recuperare le informazioni sulla versione

Version gli oggetti vengono usati più di frequente per archiviare informazioni sulla versione su alcuni componenti di sistema o dell'applicazione (ad esempio il sistema operativo), Common Language Runtime, l'eseguibile dell'applicazione corrente o un particolare assembly. Gli esempi seguenti illustrano alcuni degli scenari più comuni:

  • Recupero della versione del sistema operativo. Nell'esempio seguente viene utilizzata la OperatingSystem.Version proprietà per recuperare il numero di versione del sistema operativo.

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

  • Recupero della versione di Common Language Runtime. Nell'esempio seguente viene utilizzata la Environment.Version proprietà per recuperare informazioni sulla versione relative a 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())

  • Recupero della versione di assembly dell'applicazione corrente. Nell'esempio riportato di seguito viene utilizzato il metodo Assembly.GetEntryAssembly per ottenere un riferimento a un oggetto Assembly che rappresenta il file eseguibile dell'applicazione e ne recupera il numero di versione dell'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

  • Recupero della versione dell'assembly corrente. Nell'esempio seguente viene utilizzata la Type.Assembly proprietà per ottenere un riferimento a un Assembly oggetto che rappresenta l'assembly che contiene il punto di ingresso dell'applicazione e quindi recupera le relative informazioni sulla versione.

    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

  • Recupero della versione di un assembly specifico. Nell'esempio seguente viene utilizzato il Assembly.ReflectionOnlyLoadFrom metodo per ottenere un riferimento a un Assembly oggetto con un nome di file specifico e quindi recuperarne le informazioni sulla versione. Si noti che esistono anche diversi altri metodi per creare un'istanza di un Assembly oggetto in base al nome file o al nome sicuro.

    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

  • Recupero della versione di pubblicazione di un'applicazione ClickOnce. Nell'esempio seguente viene utilizzata la proprietà ApplicationDeployment.CurrentVersion per visualizzare la versione di pubblicazione di un'applicazione. Si noti che la relativa esecuzione corretta richiede l'impostazione dell'identità dell'applicazione dell'esempio. Questa operazione è automaticamente gestita dalla Pubblicazione guidata di 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

    La versione di un'applicazione per la distribuzione ClickOnce è completamente indipendente dalla versione di assembly.

Confrontare gli oggetti versione

È possibile utilizzare il CompareTo metodo per determinare se un Version oggetto è precedente, uguale o successivo a un secondo Version oggetto. L'esempio seguente indica che la versione 2.1 è successiva alla versione 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.

Affinché due versioni siano uguali, i numeri principali, secondari, di compilazione e di revisione del primo Version oggetto devono essere identici a quelli del secondo Version oggetto. Se il numero di compilazione o revisione di un Version oggetto non è definito, tale Version oggetto viene considerato precedente a un Version oggetto il cui numero di compilazione o revisione è uguale a zero. Nell'esempio seguente viene illustrato il confronto di tre Version oggetti con componenti di versione non definiti.

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