Vorgehensweise: Bestimmen der installierten .NET Framework-Versionen

Sie können mehrere Versionen von .NET Framework auf einem Computer installieren und ausführen.

• Wenn Sie die Versionen auf Ihrem eigenen Computer überprüfen möchten, geht dies am einfachsten über Systemsteuerung>Programme>Programme und Featuresoder in Einstellungen unter Apps>Installierte Apps. Sie können auch diese von der Community verwalteten Tools verwenden.
• Als App-Entwickler müssen Sie möglicherweise herausfinden, welche Versionen von .NET Framework auf dem Computer des App-Benutzers installiert sind. Die Registrierung enthält eine Liste der auf einem Computer installierten .NET Framework-Versionen. Sie können auch die RuntimeInformation.FrameworkDescription-Eigenschaft ändern.
• Informationen zur CLR-Version, die separat versioniert werden, finden Sie unter Suchen von CLR-Versionen.

Das .NET Framework besteht aus zwei Hauptkomponenten mit separaten Versionen:

• Ein Satz von Assemblys, bei denen es sich um Sammlungen von Typen und Ressourcen handelt, die die Funktionalität Ihre Apps bereitstellen. .NET Framework und Assemblys verwenden die gleiche Versionsnummer. Beispielsweise zählen zu den .NET Framework-Versionen 4.5, 4.6.1 und 4.7.2.
• Die CLR (Common Language Runtime, CLR), die den Code Ihrer App verwaltet und ausführt. Eine einzelne CLR-Version unterstützt in der Regel mehrere .NET Framework-Versionen. Beispiel: Die Version 4.0.30319.xxxxx der CLR (wobei xxxxx kleiner als 42000 ist) unterstützt die Versionen 4 bis 4.5.2 des .NET Frameworks. Ab Version 4.0.30319.42000 unterstützt die CLR Version 4.6 und höher des .NET Frameworks.

Von der Community verwaltete Tools

Mithilfe von Tools, die von der Community verwaltet werden, können Sie ermittelt, welche .NET Framework-Versionen installiert sind:

• https://github.com/jmalarcon/DotNetVersions
• https://github.com/EliteLoser/DotNetVersionLister

RuntimeInformation.FrameworkDescription-Eigenschaft

Sie können die RuntimeInformation.FrameworkDescription-Eigenschaft verwenden, um programmgesteuert abzufragen, unter welcher .NET-Version Ihre App ausgeführt wird. Wenn die App auf dem .NET Framework ausgeführt wird, sieht die Ausgabe in etwa wie folgt aus:

.NET Framework 4.8.4250.0

Im Vergleich dazu, sieht die Ausgabe wie folgt aus, wenn die App mit .NET Core oder .NET 5 oder höher ausgeführt wird:

.NET Core 3.1.9
.NET 5.0.0

Registrierung

Mit der Registrierung können Sie ermitteln, welche .NET Framework-Version installiert ist. Die Schlüssel unterscheiden sich für .NET Framework 1.0–4.0 und .NET Framework 4.5+. Sie können den Registrierungs-Editor, PowerShell oder Code verwenden, um die Registrierung zu überprüfen.

• .NET Framework 4.5 und höhere Versionen
  • Registrierungs-Editor
  • Abfragen mit Code
  • Abfragen mithilfe von PowerShell
• .NET Framework 1.0–4.0
  • Registrierungs-Editor
  • Abfragen mit Code
  • Abfragen mithilfe von PowerShell

.NET Framework 4.5 und höhere Versionen

Die Version des .NET Frameworks (4.5 und höher), die auf einem Computer installiert ist, wird in der Registrierung unter HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full aufgeführt. Wenn der Unterschlüssel Full fehlt, ist weder .NET Framework 4.5 noch eine höhere Version installiert.

Der Release-Wert REG_DWORD in der Registrierung steht für die installierte .NET Framework-Version.

Mindestversion

Wenn Sie bestimmen möchten, ob eine Mindestversion des .NET Framework vorhanden ist, suchen Sie nach einem REG_DWORD-Wert des Release, der höher oder gleich dem entsprechenden in der folgenden Tabelle aufgeführten Wert ist. Wenn Ihre Anwendung beispielsweise unter .NET Framework 4.8 oder einer höheren Version ausgeführt wird, testen Sie, ob der Releasewert für REG_DWORD größer oder gleich 528040 ist.

Verwenden des Registrierungs-Editors

1. Wählen Sie im Menü Start die Option Ausführen aus, geben Sie regedit ein, und klicken Sie dann auf OK.

   (Sie müssen über Administratorrechte verfügen, um regedit ausführen zu können.)

2. Öffnen Sie im Registrierungs-Editor den folgenden Unterschlüssel: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full. Wenn der Unterschlüssel Full nicht vorhanden ist, wurde .NET Framework 4.5 oder höher nicht installiert.

3. Suchen Sie nach einem REG_DWORD-Eintrag mit dem Namen Release. Wenn dieser vorhanden ist, haben Sie .NET Framework 4.5 oder höher installiert. Der zugehörige Wert entspricht einer bestimmten Version des .NET Frameworks. In der folgenden Abbildung weist der Eintrag Release beispielsweise den Wert 528040 auf, was dem Releaseschlüssel für .NET Framework 4.8 entspricht.

   

Verwenden von PowerShell zum Prüfen auf eine Mindestversion

Verwenden Sie PowerShell-Befehle, um den Wert des Eintrags Release des Unterschlüssels HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full zu überprüfen.

In den folgenden Beispielen wird der Wert des Eintrags Release überprüft, um zu bestimmen, ob .NET Framework 4.6.2 oder höher installiert ist. Dieser Code gibt True zurück, wenn es installiert ist, und andernfalls False.

(Get-ItemPropertyValue -LiteralPath 'HKLM:SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full' -Name Release) -ge 394802

Abfragen der Registrierung mithilfe von Code

1. Verwenden Sie die Methoden RegistryKey.OpenBaseKey und RegistryKey.OpenSubKey, um auf den Unterschlüssel HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full in der Windows-Registrierung zuzugreifen.

   Wichtig

   Wenn die App, die Sie ausführen, für 32 Bit optimiert ist und unter einer 64-Bit-Version von Windows ausgeführt wird, unterscheiden sich die Registrierungspfade von den zuvor aufgeführten. Die 32-Bit-Registrierung ist im Unterschlüssel HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\ verfügbar. Der Registrierungsunterschlüssel für .NET Framework 4.5 ist beispielsweise HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\NET Framework Setup\NDP\v4\Full.

2. Überprüfen Sie den Release-Wert für REG_DWORD, um die installierte Version zu bestimmen. Suchen Sie einen Wert größer als oder gleich dem Wert, der in der .NET Framework-Versionstabelle aufgeführt ist, um die Aufwärtskompatibilität zu überprüfen.

Im folgenden Beispiel wird der Wert des Eintrags Release in der Registrierung überprüft, um die installierten Versionen von .NET Framework 4.5 bis 4.8.1 und höher zu suchen.

const string subkey = @"SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full\";

using (var ndpKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32).OpenSubKey(subkey))
{
    if (ndpKey != null && ndpKey.GetValue("Release") != null)
    {
        Console.WriteLine($".NET Framework Version: {CheckFor45PlusVersion((int)ndpKey.GetValue("Release"))}");
    }
    else
    {
        Console.WriteLine(".NET Framework Version 4.5 or later is not detected.");
    }
}

// Checking the version using >= enables forward compatibility.
string CheckFor45PlusVersion(int releaseKey)
{
    if (releaseKey >= 533320)
        return "4.8.1 or later";
    if (releaseKey >= 528040)
        return "4.8";
    if (releaseKey >= 461808)
        return "4.7.2";
    if (releaseKey >= 461308)
        return "4.7.1";
    if (releaseKey >= 460798)
        return "4.7";
    if (releaseKey >= 394802)
        return "4.6.2";
    if (releaseKey >= 394254)
        return "4.6.1";
    if (releaseKey >= 393295)
        return "4.6";
    if (releaseKey >= 379893)
        return "4.5.2";
    if (releaseKey >= 378675)
        return "4.5.1";
    if (releaseKey >= 378389)
        return "4.5";
    // This code should never execute. A non-null release key should mean
    // that 4.5 or later is installed.
    return "No 4.5 or later version detected";
}

Private Sub Get45PlusFromRegistry()
    Const subkey As String = "SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full\"

    Using ndpKey As RegistryKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32).OpenSubKey(subkey)
        If ndpKey IsNot Nothing AndAlso ndpKey.GetValue("Release") IsNot Nothing Then
            Console.WriteLine($".NET Framework Version: {CheckFor45PlusVersion(ndpKey.GetValue("Release"))}")
        Else
            Console.WriteLine(".NET Framework Version 4.5 or later is not detected.")
        End If
    End Using
End Sub

' Checking the version using >= enables forward compatibility.
Private Function CheckFor45PlusVersion(releaseKey As Integer) As String
    If releaseKey >= 533320 Then
        Return "4.8.1 or later"
    ElseIf releaseKey >= 528040 Then
        Return "4.8"
    ElseIf releaseKey >= 461808 Then
        Return "4.7.2"
    ElseIf releaseKey >= 461308 Then
        Return "4.7.1"
    ElseIf releaseKey >= 460798 Then
        Return "4.7"
    ElseIf releaseKey >= 394802 Then
        Return "4.6.2"
    ElseIf releaseKey >= 394254 Then
        Return "4.6.1"
    ElseIf releaseKey >= 393295 Then
        Return "4.6"
    ElseIf releaseKey >= 379893 Then
        Return "4.5.2"
    ElseIf releaseKey >= 378675 Then
        Return "4.5.1"
    ElseIf releaseKey >= 378389 Then
        Return "4.5"
    End If
    ' This code should never execute. A non-null release key should mean
    ' that 4.5 or later is installed.
    Return "No 4.5 or later version detected"
End Function

In diesem Beispiel wird die folgende Ausgabe angezeigt:

.NET Framework Version: 4.6.1

Abfragen der Registrierung mithilfe von PowerShell

Im folgenden Beispiel wird der Wert des Eintrags Release in der Registrierung mithilfe von PowerShell überprüft, um die installierten Versionen von .NET Framework 4.5 bis 4.8.1 und höher zu suchen:

$release = Get-ItemPropertyValue -LiteralPath 'HKLM:SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full' -Name Release
switch ($release) {
    { $_ -ge 533320 } { $version = '4.8.1 or later'; break }
    { $_ -ge 528040 } { $version = '4.8'; break }
    { $_ -ge 461808 } { $version = '4.7.2'; break }
    { $_ -ge 461308 } { $version = '4.7.1'; break }
    { $_ -ge 460798 } { $version = '4.7'; break }
    { $_ -ge 394802 } { $version = '4.6.2'; break }
    { $_ -ge 394254 } { $version = '4.6.1'; break }
    { $_ -ge 393295 } { $version = '4.6'; break }
    { $_ -ge 379893 } { $version = '4.5.2'; break }
    { $_ -ge 378675 } { $version = '4.5.1'; break }
    { $_ -ge 378389 } { $version = '4.5'; break }
    default { $version = $null; break }
}

if ($version) {
    Write-Host -Object ".NET Framework Version: $version"
} else {
    Write-Host -Object '.NET Framework Version 4.5 or later is not detected.'
}

In diesem Beispiel wird der empfohlenen Vorgehensweise zur Versionsprüfung gefolgt:

• Er überprüft, ob der Wert des Releaseeintrags größer oder gleich dem Wert der bekannten Releasewerte ist.
• Es wird beginnend mit der neuesten Version bis hin zur ältesten Version geprüft.

.NET Framework 1.0–4.0

Jede Version von .NET Framework zwischen den Versionen 1.1 und 4.0 wird unter HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP als Unterschlüssel aufgeführt. In der folgenden Tabelle wird der Pfad zu den einzelnen .NET Framework-Versionen aufgelistet. Für die meisten Versionen gibt es einen Install-Wert für REG_DWORD von 1, der angibt, dass die jeweilige Version installiert ist. In diesen Unterschlüsseln gibt es auch einen Version-Wert für REG_SZ, der eine Versionszeichenfolge enthält.

Hinweis: Der Registrierungspfad für den Unterschlüssel für .NET Framework 1.0 unterscheidet sich von dem anderer Registrierungsschlüssel.

Verwenden des Registrierungs-Editors (ältere Frameworkversionen)

1. Wählen Sie im Menü Start die Option Ausführen aus, geben Sie regedit ein, und klicken Sie dann auf OK.

   Sie müssen über Administratorrechte verfügen, um regedit ausführen zu können.

2. Öffnen Sie den Unterschlüssel, der der Version entspricht, die Sie überprüfen möchten. Verwenden Sie die Tabelle im Abschnitt .NET Framework 1.0–4.0.

   Die folgende Abbildung zeigt den Unterschlüssel und dessen Version-Wert für .NET Framework 3.5.

   

Abfragen der Registrierung mithilfe von Code (ältere Frameworkversionen)

Verwenden Sie die Klasse Microsoft.Win32.RegistryKey, um in der Windows-Registrierung auf den Unterschlüssel HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP zuzugreifen.

Im folgenden Beispiel werden die installierten .NET Framework-Versionen 1–4 ermittelt:

// Open the registry key for the .NET Framework entry.
using (RegistryKey ndpKey =
        RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32).
        OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP\"))
{
    foreach (var versionKeyName in ndpKey.GetSubKeyNames())
    {
        // Skip .NET Framework 4.5 version information.
        if (versionKeyName == "v4")
        {
            continue;
        }

        if (versionKeyName.StartsWith("v"))
        {
            RegistryKey versionKey = ndpKey.OpenSubKey(versionKeyName);

            // Get the .NET Framework version value.
            var name = (string)versionKey.GetValue("Version", "");
            // Get the service pack (SP) number.
            var sp = versionKey.GetValue("SP", "").ToString();

            // Get the installation flag.
            var install = versionKey.GetValue("Install", "").ToString();
            if (string.IsNullOrEmpty(install))
            {
                // No install info; it must be in a child subkey.
                Console.WriteLine($"{versionKeyName}  {name}");
            }
            else if (install == "1")
            {
                // Install = 1 means the version is installed.

                if (!string.IsNullOrEmpty(sp))
                {
                    Console.WriteLine($"{versionKeyName}  {name}  SP{sp}");
                }
                else
                {
                    Console.WriteLine($"{versionKeyName}  {name}");
                }
            }

            if (!string.IsNullOrEmpty(name))
            {
                continue;
            }
            // else print out info from subkeys...

            // Iterate through the subkeys of the version subkey.
            foreach (var subKeyName in versionKey.GetSubKeyNames())
            {
                RegistryKey subKey = versionKey.OpenSubKey(subKeyName);
                name = (string)subKey.GetValue("Version", "");
                if (!string.IsNullOrEmpty(name))
                    sp = subKey.GetValue("SP", "").ToString();

                install = subKey.GetValue("Install", "").ToString();
                if (string.IsNullOrEmpty(install))
                {
                    // No install info; it must be later.
                    Console.WriteLine($"  {versionKeyName}  {name}");
                }
                else if (install == "1")
                {
                    if (!string.IsNullOrEmpty(sp))
                    {
                        Console.WriteLine($"  {subKeyName}  {name}  SP{sp}");
                    }
                    else
                    {
                        Console.WriteLine($"  {subKeyName}  {name}");
                    }
                }
            }
        }
    }
}

' Opens the registry key for the .NET Framework entry.
Using ndpKey As RegistryKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32).
    OpenSubKey("SOFTWARE\Microsoft\NET Framework Setup\NDP\")

    For Each versionKeyName In ndpKey.GetSubKeyNames()
        ' Skip .NET Framework 4.5 and later.
        If versionKeyName = "v4" Then Continue For

        If versionKeyName.StartsWith("v") Then
            Dim versionKey As RegistryKey = ndpKey.OpenSubKey(versionKeyName)
            ' Get the .NET Framework version value.
            Dim name = DirectCast(versionKey.GetValue("Version", ""), String)
            ' Get the service pack (SP) number.
            Dim sp = versionKey.GetValue("SP", "").ToString()

            Dim install = versionKey.GetValue("Install", "").ToString()
            If String.IsNullOrEmpty(install) Then
                ' No install info; it must be in a child subkey.
                Console.WriteLine($"{versionKeyName}  {name}")
            ElseIf install = "1" Then

                If Not String.IsNullOrEmpty(sp) Then
                    Console.WriteLine($"{versionKeyName}  {name}  SP{sp}")
                Else
                    Console.WriteLine($"{versionKeyName}  {name}")
                End If

            End If

            If Not String.IsNullOrEmpty(name) Then
                Continue For
            End If

            For Each subKeyName In versionKey.GetSubKeyNames()
                Dim subKey As RegistryKey = versionKey.OpenSubKey(subKeyName)
                name = DirectCast(subKey.GetValue("Version", ""), String)
                If Not String.IsNullOrEmpty(name) Then
                    sp = subKey.GetValue("SP", "").ToString()
                End If

                install = subKey.GetValue("Install", "").ToString()
                If String.IsNullOrEmpty(install) Then
                    ' No install info; it must be later.
                    Console.WriteLine($"  {versionKeyName}  {name}")
                ElseIf install = "1" Then

                    If Not String.IsNullOrEmpty(sp) Then
                        Console.WriteLine($"  {subKeyName}  {name}  SP{sp}")
                    Else
                        Console.WriteLine($"  {subKeyName}  {name}")
                    End If

                End If
            Next
        End If
    Next
End Using

Die Konsole zeigt eine Ausgabe an, die der folgenden in etwa entspricht:

v2.0.50727  2.0.50727.4927  SP2
v3.0  3.0.30729.4926  SP2
v3.5  3.5.30729.4926  SP1
v4.0
  Client  4.0.0.0

Abfragen der Registrierung mithilfe von PowerShell (ältere Framework-Versionen)

Im folgenden Beispiel wird der Wert des Eintrags Release in der Registrierung mithilfe von PowerShell überprüft, um die installierten Versionen von .NET Framework 1 bis 4 und höher zu suchen:

Get-ChildItem -Path 'HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP' |
Where-Object { ($_.PSChildName -ne "v4") -and ($_.PSChildName -like 'v*') } |
ForEach-Object {
    $name = $_.Version
    $sp = $_.SP
    $install = $_.Install
    if (-not $install) {
        Write-Host -Object "$($_.PSChildName)  $($name)"
    }
    elseif ($install -eq '1') {
        if (-not $sp) {
            Write-Host -Object "$($_.PSChildName)  $($name)"
        }
        else {
            Write-Host -Object "$($_.PSChildName)  $($name) SP$($sp)"
        }
}
    if (-not $name) {
        $parentName = $_.PSChildName
        Get-ChildItem -LiteralPath $_.PSPath |
        Where-Object {
            if ($_.Property -contains 'Version') { $name = $((Get-ItemProperty -Path "Registry::$_").Version) }
            if ($name -and ($_.Property -contains 'SP')) { $sp = $((Get-ItemProperty -Path "Registry::$_").SP) }
            if ($_.Property -contains 'Install') { $install = $((Get-ItemProperty -Path "Registry::$_").Install) }
            if (-not $install) {
                Write-Host -Object "  $($parentName)  $($name)"
            }
            elseif ($install -eq '1') {
                if (-not $sp) {
                    Write-Host -Object "  $($_.PSChildName)  $($name)"
                }
                else {
                    Write-Host -Object "  $($_.PSChildName)  $($name) SP$($sp)"
                }
            }
        }
    }
}

Suchen von CLR-Versionen

Die mit dem für .NET Framework installierte CLR-Version wird separat bestimmt. Es gibt zwei Möglichkeiten, die Version der .NET Framework-CLR zu ermitteln:

• Das Tool Clrver.exe
• Die Environment.Version-Eigenschaft

Das Tool Clrver.exe

Verwenden Sie das CLR-Versionstool (Clrver.exe), um zu ermitteln, welche Versionen der CLR auf einem Computer installiert sind. Öffnen Sie die Developer-Eingabeaufforderung von Visual Studio oder Visual Studio Developer PowerShell, und geben Sie clrver ein.

Beispielausgabe:

Versions installed on the machine:
v2.0.50727
v4.0.30319

Die Environment.Version-Eigenschaft.

1. Fragen Sie die Eigenschaft Environment.Version ab, um ein Version-Objekt abzurufen.

   Das zurückgegebene System.Version-Objekt identifiziert die Version der Runtime, die gerade den Code ausführt. Es gibt keine Assemblyversionen oder andere Versionen der Runtime zurück, die möglicherweise auf dem Computer installiert wurden.

   Bei den .NET Framework-Versionen 4, 4.5, 4.5.1 und 4.5.2 hat die Zeichenfolgendarstellung des zurückgegebenen Version-Objekts das Format 4.0.30319.xxxxx, wobei xxxxx kleiner als 42000 ist. Bei .NET Framework 4.6 und höheren Versionen weist es das Format 4.0.30319.42000 auf.

2. Fragen Sie das erhaltene Version-Objekt wie folgt ab:

   • Verwenden Sie für den Hauptversionsbezeichner (zum Beispiel 4 für Version 4.0) die Eigenschaft Version.Major.
   • Verwenden Sie für den Nebenversionsbezeichner (zum Beispiel 0 für Version 4.0) die Eigenschaft Version.Minor.
   • Verwenden Sie für die gesamte Versionszeichenfolge (zum Beispiel 4.0.30319.18010) die Methode Version.ToString. Diese Methode gibt einen einzelnen Wert zurück, der die Version der Runtime widerspiegelt, die den Code ausführt. Sie gibt keine Assemblyversionen oder andere Runtimeversionen zurück, die möglicherweise auf dem Computer installiert sind.

Im folgenden Beispiel wird die Eigenschaft Environment.Version verwendet, um CLR-Versionsinformationen abzurufen:

Console.WriteLine($"Version: {Environment.Version}");

Console.WriteLine($"Version: {Environment.Version}")

Die Konsole zeigt eine Ausgabe an, die der folgenden in etwa entspricht:

Version: 4.0.30319.18010

Siehe auch

• How to: Ermitteln der installierten .NET Framework-Sicherheitsupdates und -Hotfixes
• Problembehandlung: Ermitteln der installierten Versionen und Service Packs von .NET Framework
• Installieren von .NET Framework für Entwickler
• .NET Framework-Versionen und -Abhängigkeiten