System.Version-Klasse

Dieser Artikel enthält ergänzende Hinweise zur Referenzdokumentation für diese API.

Die Version Klasse stellt die Versionsnummer einer Assembly, eines Betriebssystems oder der Common Language Runtime dar. Versionsnummern bestehen aus zwei bis vier Komponenten: Haupt-, Neben-, Build- und Überarbeitungskomponenten. Die Haupt- und Hilfskomponenten sind erforderlich; Die Build- und Revisionskomponenten sind optional, die Buildkomponente ist jedoch erforderlich, wenn die Revisionskomponente definiert ist. Alle definierten Komponenten müssen ganze Zahlen größer oder gleich 0 sein. Das Format der Versionsnummer lautet wie folgt (optionale Komponenten werden in eckigen Klammern angezeigt):

Hauptversion. Nebenversion[.Buildnummer[.Revision]]

Die Komponenten werden gemäß der Konvention wie folgt verwendet:

• Hauptversion: Assemblys mit demselben Namen, aber verschiedenen Hauptversionen sind nicht austauschbar. Eine höhere Versionsnummer kann möglicherweise eine vollständige Überarbeitung eines Produkts angeben, bei dem die Abwärtskompatibilität nicht vorausgesetzt werden kann.

• Nebenversion: Wenn der Name und die Nummer der Hauptversion für zwei Assemblys identisch sind, sich jedoch die Nummer der Nebenversion unterscheidet, kann davon ausgegangen werden, dass Verbesserungen vorgenommen wurden, während gleichzeitig die Abwärtskompatibilität gewährleistet wird. Diese höhere Nebenversionsnummer kann auf die Nebenversion eines Produkts oder eine neuen Produktversion mit vollständiger Abwärtskompatibilität hindeuten.

• Buildnummer: ein Unterschied in der Buildnummer verweist auf eine Neukompilierung der gleichen Quelle. Verschiedene Buildnummern können verwendet werden, wenn der Prozessor, die Plattform oder der Compiler geändert wird.

• Revision: Assemblys mit demselben Namen, Haupt- und Nebenversionsnummern, aber verschiedene Überarbeitungen sollen vollständig austauschbar sein. Eine höhere Revisionsnummer kann in einem Build verwendet werden, der ein Sicherheitsloch in einer zuvor veröffentlichten Assembly behebt.

Nachfolgende Versionen einer Assembly, die sich nur durch Build- oder Revisionsnummern unterscheiden, gelten als Hotfixupdates der vorherigen Version.

Wichtig

Der Wert von Version Eigenschaften, denen nicht explizit ein Wert zugewiesen wurde, ist nicht definiert (-1).

Mit MajorRevision den Eigenschaften MinorRevision können Sie eine temporäre Version Ihrer Anwendung identifizieren, die beispielsweise ein Problem korrigiert, bis Sie eine dauerhafte Lösung freigeben können. Darüber hinaus verwendet das Windows NT-Betriebssystem die MajorRevision Eigenschaft, um die Service Pack-Nummer zu codieren.

Zuweisen von Versionsinformationen zu Assemblys

Ordinarily, the Version class is not used to assign a version number to an assembly. Stattdessen wird die AssemblyVersionAttribute Klasse verwendet, um die Version einer Assembly zu definieren, wie im Beispiel in diesem Artikel dargestellt.

Abrufen von Versionsinformationen

Version Objekte werden am häufigsten verwendet, um Versionsinformationen zu einigen System- oder Anwendungskomponenten (z. B. dem Betriebssystem), der Common Language Runtime, der ausführbaren Datei der aktuellen Anwendung oder einer bestimmten Assembly zu speichern. Die folgenden Beispiele veranschaulichen einige der am häufigsten verwendeten Szenarien:

• Abrufen der Betriebssystemversion. Im folgenden Beispiel wird die OperatingSystem.Version Eigenschaft verwendet, um die Versionsnummer des Betriebssystems abzurufen.

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

• Abrufen der Version der Common Language Runtime. Im folgenden Beispiel wird die Environment.Version Eigenschaft verwendet, um Versionsinformationen über die Common Language Runtime abzurufen.

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

• Abrufen der Assemblyversion der aktuellen Anwendung. Im folgenden Beispiel wird die Assembly.GetEntryAssembly Methode verwendet, um einen Verweis auf ein Assembly Objekt abzurufen, das die ausführbare Anwendung darstellt, und ruft dann die Assemblyversionsnummer ab.

  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
  

• Abrufen der Assemblyversion der aktuellen Assembly. Im folgenden Beispiel wird die Type.Assembly Eigenschaft verwendet, um einen Verweis auf ein Assembly Objekt abzurufen, das die Assembly darstellt, die den Einstiegspunkt der Anwendung enthält, und ruft dann die Versionsinformationen ab.

  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
  

• Abrufen der Version einer bestimmten Assembly. Im folgenden Beispiel wird die Assembly.ReflectionOnlyLoadFrom Methode verwendet, um einen Verweis auf ein Assembly Objekt abzurufen, das einen bestimmten Dateinamen aufweist, und ruft dann die Versionsinformationen ab. Beachten Sie, dass mehrere andere Methoden auch vorhanden sind, um ein Assembly Objekt anhand des Dateinamens oder durch starken Namen zu instanziieren.

  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
  

• Abrufen der Veröffentlichungsversion einer ClickOnce-Anwendung. Im folgenden Beispiel wird die Eigenschaft verwendet, um die ApplicationDeployment.CurrentVersion Veröffentlichungsversion einer Anwendung anzuzeigen. Beachten Sie, dass für die erfolgreiche Ausführung die Anwendungsidentität des Beispiels festgelegt werden muss. Dies wird automatisch vom Visual Studio-Veröffentlichungs-Assistenten behandelt.

  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
  

  Wichtig

  Die Veröffentlichungsversion einer Anwendung für die ClickOnce-Bereitstellung ist vollständig unabhängig von der Assemblyversion.

Vergleichen von Versionsobjekten

Mit der CompareTo Methode können Sie ermitteln, ob ein Version Objekt früher als, identisch mit oder höher als ein zweites Version Objekt ist. Im folgenden Beispiel wird angegeben, dass Version 2.1 höher als Version 2.0 ist.

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.

Damit zwei Versionen gleich sind, müssen die Haupt-, Neben-, Build- und Revisionsnummern des ersten Version Objekts mit denen des zweiten Version Objekts identisch sein. Wenn die Build- oder Revisionsnummer eines Version Objekts nicht definiert ist, gilt dieses Version Objekt als früher als ein Version Objekt, dessen Build- oder Revisionsnummer gleich Null ist. Im folgenden Beispiel wird dies veranschaulicht, indem drei Version Objekte mit nicht definierten Versionskomponenten verglichen werden.

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