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 Kontrolna tabla> Programprogramprogram>och funktioner, eller i Inställningar under Appar>Installerade appar. Du kan också använda dessa community-underhållna verktyg.
• 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 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+, ser utdata ut ungefär så här:

.NET Core 3.1.9
.NET 5.0.0

Register

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.

Minimiversion

Om du vill avgöra om en lägsta version av .NET Framework finns 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 testar du ett versionsvärde REG_DWORD 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 versionsposten 528040, som är versionsnyckeln 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 versionsposten för HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full undernyckel.

I följande exempel kontrollerar du värdet för versionsposten för att avgöra om .NET Framework 4.6.2 eller senare har installerats. 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. RegistryKey.OpenBaseKey Använd metoderna och RegistryKey.OpenSubKey för att komma åt HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full undernyckel 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 undernyckeln HKEY_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 för versionsposten 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 (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

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 för versionsposten i registret för att hitta de 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 versionsposten är större än eller lika med värdet för de kända versionsnycklarna.
• 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 det ett Install REG_DWORD värde 1 för 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.
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

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 versionsposten i registret för att hitta de 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-ItemPropertyValue -Path $_.PSPath -Name Version }
            if ($name -and ($_.Property -contains 'SP')) { $sp = Get-ItemPropertyValue -Path $_.PSPath -Name SP }
            if ($_.Property -contains 'Install') { $install = Get-ItemPropertyValue -Path $_.PSPath -Name 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 version. 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 körningen som för närvarande kör koden. Den returnerar inte sammansättningsversioner eller andra versioner av körningen som kan ha 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 Version.ToString (till exempel 4.0.30319.18010). Den här metoden returnerar ett enda värde som återspeglar den version av körningen 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