Anvisningar: Avgöra vilka .NET Framework-versioner som är installerade

Du kan installera och köra flera versioner av .NET Framework på en dator.

• Om du vill kontrollera versionerna på din egen dator är det enklaste sättet att gå igenomProgram>och funktioner på > eller i Inställningar under Appar>Installerade appar. Du kan också använda dessa verktyg som underhålls av gemenskapen.
• Om du är apputvecklare kan du behöva veta vilka .NET Framework-versioner som är installerade på appanvändarens dator. Registret innehåller en lista över de versioner av .NET Framework som är installerade på datorn. Du kan också fråga efter egenskapenRuntimeInformation.FrameworkDescription.
• Information om hur du hittar CLR-versionen, som är separat version, finns i Hitta CLR-versioner.

.NET Framework består av två huvudkomponenter som är versionshanterade separat:

• En uppsättning sammansättningar, som är samlingar av typer och resurser som tillhandahåller funktionerna för dina appar. .NET Framework och sammansättningarna delar samma versionsnummer. .NET Framework-versioner inkluderar till exempel 4.5, 4.6.1 och 4.7.2.
• CLR (Common Language Runtime), som hanterar och kör appens kod. En enda CLR-version stöder vanligtvis flera .NET Framework-versioner. Till exempel CLR version 4.0.30319. xxxxx där xxxxx är mindre än 42000, stöder .NET Framework version 4 till 4.5.2. CLR-versionen som är större än eller lika med 4.0.30319.42000 stöder .NET Framework-versioner som börjar med .NET Framework 4.6.

Community-underhållna verktyg

Community-underhållna verktyg är tillgängliga för att identifiera vilka .NET Framework-versioner som är installerade:

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

RuntimeInformation.FrameworkDescription egenskap

Du kan använda RuntimeInformation.FrameworkDescription egenskapen för att programmatiskt fråga efter vilken .NET-version din app körs på. Om appen körs på .NET Framework ser utdata ut ungefär så här:

.NET Framework 4.8.4250.0

Om appen körs på .NET Core eller .NET 5+, kommer resultatet att se ut ungefär så här:

.NET Core 3.1.9
.NET 5.0.0

Registry

Du kan använda registret för att identifiera vilken .NET Framework-version som är installerad. Nycklarna skiljer sig åt för .NET Framework 1.0-4.0 och .NET Framework 4.5+. Du kan använda Registereditorn, PowerShell eller kod för att kontrollera registret.

• .NET Framework 4.5 och senare versioner
  • Registereditorn
  • Fråga med hjälp av kod
  • Fråga med PowerShell
• .NET Framework 1.0-4.0
  • Registereditorn
  • Fråga med hjälp av kod
  • Fråga med PowerShell

.NET Framework 4.5 och senare versioner

Versionen av .NET Framework (4.5 och senare) som är installerad på en dator visas i registret på HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full. Om den fullständiga undernyckeln saknas installeras inte .NET Framework 4.5 eller senare.

Värdet Release REG_DWORD i registret representerar den version av .NET Framework som är installerad.

Lägsta version

Om du vill ta reda på om det finns en lägsta version av .NET Framework kontrollerar du om det finns ett Versions-REG_DWORD-värde som är större än eller lika med motsvarande värde som anges i följande tabell. Om ditt program till exempel körs under .NET Framework 4.8 eller en senare version ska du kontrollera ett Release REG_DWORD-värde som är större än eller lika med 528040.

Använda Registereditorn

1. Välj Kör på Start-menyn, ange regedit och välj sedan OK.

   (Du måste ha administrativa autentiseringsuppgifter för att köra regedit.)

2. Öppna följande undernyckel i Registereditorn: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full. Om den fullständiga undernyckeln inte finns har du inte .NET Framework 4.5 eller senare installerat.

3. Sök efter en REG_DWORD post med namnet Release. Om den finns har du .NET Framework 4.5 eller senare installerat. Dess värde motsvarar en viss version av .NET Framework. I följande bild är till exempel värdet för Release 528040, vilket är releasenyckeln för .NET Framework 4.8.

   

Använd PowerShell för att söka efter en lägsta version

Använd PowerShell-kommandon för att kontrollera värdet för Release-posten i HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full-undernyckeln.

I följande exempel kontrolleras värdet för Release-posten för att avgöra om .NET Framework 4.6.2 eller senare är installerad. Den här koden returnerar True om den är installerad och False på annat sätt.

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

Fråga registret med hjälp av kod

1. Använd RegistryKey.OpenBaseKey och RegistryKey.OpenSubKey metoderna för att komma åt HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full -undernyckeln i Windows-registret.

   Viktigt!

   Om appen du kör är 32-bitars och körs i 64-bitars Windows kommer registersökvägarna att skilja sig från tidigare. 32-bitarsregistret är tillgängligt i undernyckelnHKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\ . Registerundernyckeln för .NET Framework 4.5 är till exempel HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\NET Framework Setup\NDP\v4\Full.

2. Kontrollera värdet REG_DWORD release för att fastställa den installerade versionen. Om du vill vara framåtkompatibel kontrollerar du om det finns ett värde som är större än eller lika med det värde som anges i .NET Framework-versionstabellen.

I följande exempel kontrolleras värdet av Release-posten i registret för att hitta de versioner av .NET Framework 4.5-4.8.1 som är installerade.

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

using (RegistryKey baseKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32))
using (RegistryKey ndpKey = baseKey.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 baseKey As RegistryKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32),
          ndpKey As RegistryKey = baseKey.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
    Select Case releaseKey
        Case >= 533320 : Return "4.8.1 or later"
        Case >= 528040 : Return "4.8"
        Case >= 461808 : Return "4.7.2"
        Case >= 461308 : Return "4.7.1"
        Case >= 460798 : Return "4.7"
        Case >= 394802 : Return "4.6.2"
        Case >= 394254 : Return "4.6.1"
        Case >= 393295 : Return "4.6"
        Case >= 379893 : Return "4.5.2"
        Case >= 378675 : Return "4.5.1"
        Case >= 378389 : Return "4.5"
        Case Else
            Return "No 4.5 or later version detected"
    End Select
End Function

I exemplet visas utdata som följande:

.NET Framework Version: 4.6.1

Fråga registret med hjälp av PowerShell

I följande exempel används PowerShell för att kontrollera värdet i Release-posten i registret för att identifiera vilka versioner av .NET Framework 4.5-4.8.1 som är installerade.

$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.'
}

Det här exemplet följer den rekommenderade metoden för versionskontroll:

• Den kontrollerar om värdet för Release-posten är större än eller lika med värdena för de kända versionsvärdena.
• Den kontrollerar i ordning från den senaste versionen till den tidigaste versionen.

.NET Framework 1.0-4.0

Varje version av .NET Framework från 1.1 till 4.0 visas som en undernyckel på HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP. I följande tabell visas sökvägen till varje .NET Framework-version. För de flesta versioner finns värdet Installera REG_DWORD 1 som anger att den här versionen är installerad. I dessa undernycklar finns det också ett version REG_SZ-värde som innehåller en versionssträng.

Observera att registersökvägen till .NET Framework 1.0-undernyckeln skiljer sig från de andra.

Använda Registereditorn (äldre ramverksversioner)

1. Välj Kör på Start-menyn, ange regedit och välj sedan OK.

   Du måste ha administrativa autentiseringsuppgifter för att köra regedit.

2. Öppna undernyckeln som matchar den version som du vill kontrollera. Använd tabellen i avsnittet .NET Framework 1.0-4.0 .

   Följande bild visar undernyckeln och dess versionsvärde för .NET Framework 3.5.

   

Fråga registret med hjälp av kod (äldre ramverksversioner)

Microsoft.Win32.RegistryKey Använd klassen för att komma åt HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP-undernyckeln i Windows-registret.

I följande exempel hittar du de versioner av .NET Framework 1-4 som är installerade:

// Open the registry key for the .NET Framework entry. Dispose this object when done.
RegistryKey ndpKey =
    RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32)
        .OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP\");

foreach (string 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.
        string name = versionKey.GetValue("Version", "").ToString();

        // Get the service pack (SP) number.
        string sp = versionKey.GetValue("SP", "").ToString();

        // Get the installation flag.
        string 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))
        {
            versionKey.Dispose();
            continue;
        }

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

            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}");
            }

            // Clean up the subkey object.
            subKey.Dispose();
        }

        versionKey.Dispose();
    }
}

ndpKey.Dispose();

' Open the registry key for the .NET Framework entry. Dispose this object when done.
Dim 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 = versionKey.GetValue("Version", "").ToString()

        ' 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

            ' Install = 1 means the version is installed.
            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

            versionKey.Dispose()
            Continue For

        End If

        ' Iterate through the subkeys of the version subkey.
        For Each subKeyName In versionKey.GetSubKeyNames()

            Dim subKey As RegistryKey = versionKey.OpenSubKey(subKeyName)
            name = subKey.GetValue("Version", "").ToString()

            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

            ' Clean up the subkey object.
            subKey.Dispose()

        Next

        versionKey.Dispose()

    End If
Next

ndpKey.Dispose()

I exemplet visas utdata som liknar följande:

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

Fråga registret med hjälp av PowerShell (äldre ramverksversioner)

I följande exempel används PowerShell för att kontrollera värdet för Release-posten i registret för att avgöra vilka versioner av .NET Framework 1-4 som är installerade.

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)"
                }
            }
        }
    }
}

Hitta CLR-versioner

.NET Framework CLR som installerats med .NET Framework är separat versionerad. Det finns två sätt att identifiera versionen av .NET Framework CLR:

• Verktyget Clrver.exe
• Egenskapen Environment.Version

Verktyget Clrver.exe

Använd VERKTYGET CLR-version (Clrver.exe) för att avgöra vilka versioner av CLR som är installerade på en dator. Öppna Visual Studio Developer Command Prompt eller Visual Studio Developer PowerShell och ange clrver.

Exempel på utdata:

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

Egenskapen Environment.Version

1. Fråga egenskapen Environment.Version för att hämta ett Version objekt.

   Det returnerade System.Version objektet identifierar den version av runtime som för närvarande exekverar koden. Den returnerar inte sammansättningsversioner eller andra versioner av körmiljön som eventuellt har installerats på datorn.

   För .NET Framework version 4, 4.5, 4.5.1 och 4.5.2 har strängrepresentationen av det returnerade Version objektet formuläret 4.0.30319.xxxxx, där xxxxx är mindre än 42000. För .NET Framework 4.6 och senare versioner har det formuläret 4.0.30319.42000.

2. När du har versionsobjektet frågar du det på följande sätt:

   • Använd egenskapen för huvudversionsidentifieraren (till exempel 4 för version 4.0 Version.Major ).
   • För den mindre versionsidentifieraren (till exempel 0 för version 4.0) använder du Version.Minor egenskapen.
   • Använd metoden för hela versionssträngen (till exempel Version.ToString). Den här metoden returnerar ett enda värde som återspeglar versionen av runtime som kör koden. Den returnerar inte sammansättningsversioner eller andra körningsversioner som kan vara installerade på datorn.

I följande exempel används Environment.Version egenskapen för att hämta CLR-versionsinformation:

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

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

I exemplet visas utdata som liknar följande:

Version: 4.0.30319.18010

Se även

• Anvisningar: Avgöra vilka .NET Framework-uppdateringar som är installerade
• Felsök: Avgöra vilka versioner och servicepaket för .NET Framework som är installerade
• Installera .NET Framework för utvecklare
• .NET Framework-versioner och beroenden