Procedure: Bepalen welke .NET Framework-versies zijn geïnstalleerd

U kunt meerdere versies van .NET Framework installeren en uitvoeren op een computer.

• Als u de versies op uw eigen computer wilt controleren, is de eenvoudigste manier via>> van het Configuratiescherm of in Instellingen onder >Apps geïnstalleerde apps. U kunt deze door de community onderhouden hulpprogramma's ook gebruiken.
• Als u een app-ontwikkelaar bent, moet u mogelijk weten welke .NET Framework-versies op de computer van de app-gebruiker zijn geïnstalleerd. Het register bevat een lijst met de versies van .NET Framework die op de computer zijn geïnstalleerd. U kunt ook een query uitvoeren op de RuntimeInformation.FrameworkDescription eigenschap.
• Zie CLR-versies zoeken om de CLR-versie te vinden, die afzonderlijk is versiebeheer.

.NET Framework bestaat uit twee hoofdonderdelen, die afzonderlijk worden geversied:

• Een set assemblies, die verzamelingen van typen en resources zijn die de functionaliteit voor uw apps bieden. .NET Framework en de assembly's delen hetzelfde versienummer. .NET Framework-versies zijn bijvoorbeeld 4.5, 4.6.1 en 4.7.2.
• De Common Language Runtime (CLR), waarmee de code van uw app wordt beheerd en uitgevoerd. Een enkele CLR-versie ondersteunt doorgaans meerdere .NET Framework-versies. Bijvoorbeeld CLR versie 4.0.30319. xxxxx waarbij xxxxx kleiner is dan 42000, ondersteunt .NET Framework-versies 4 tot en met 4.5.2. CLR-versie groter dan of gelijk aan 4.0.30319.42000 ondersteunt .NET Framework-versies vanaf .NET Framework 4.6.

Door de community onderhouden hulpprogramma's

Door de community onderhouden hulpprogramma's zijn beschikbaar om te detecteren welke .NET Framework-versies zijn geïnstalleerd:

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

eigenschap RuntimeInformation.FrameworkDescription

Als u programmatisch een query wilt uitvoeren op de .NET-versie waarop uw app wordt uitgevoerd, kunt u de RuntimeInformation.FrameworkDescription eigenschap gebruiken. Als de app wordt uitgevoerd in .NET Framework, is de uitvoer vergelijkbaar met:

.NET Framework 4.8.4250.0

Ter vergelijking: als de app wordt uitgevoerd op .NET Core of .NET 5+, is de uitvoer vergelijkbaar met:

.NET Core 3.1.9
.NET 5.0.0

Registry

U kunt het register gebruiken om te detecteren welke .NET Framework-versie is geïnstalleerd. De sleutels verschillen voor .NET Framework 1.0-4.0 en .NET Framework 4.5+. U kunt Register Editor, PowerShell of programmeercode gebruiken om het register te controleren.

• .NET Framework 4.5 en latere versies
  • Registratie-editor
  • Query's uitvoeren met behulp van code
  • Query's uitvoeren met PowerShell
• .NET Framework 1.0-4.0
  • Registratie-editor
  • Query's uitvoeren met behulp van code
  • Query's uitvoeren met PowerShell

.NET Framework 4.5 en latere versies

De versie van .NET Framework (4.5 en hoger) die op een computer is geïnstalleerd, wordt vermeld in het register op HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full. Als de volledige subsleutel ontbreekt, is .NET Framework 4.5 of hoger niet geïnstalleerd.

De release-REG_DWORD-waarde in het register vertegenwoordigt de versie van .NET Framework die is geïnstalleerd.

Minimumversie

Als u wilt bepalen of een minimale versie van .NET Framework aanwezig is, controleert u op een release-REG_DWORD waarde die groter is dan of gelijk is aan de overeenkomstige waarde die wordt vermeld in de volgende tabel. Als uw toepassing bijvoorbeeld wordt uitgevoerd onder .NET Framework 4.8 of een latere versie, test u op een release-REG_DWORD waarde die groter is dan of gelijk is aan 528040.

Register-editor gebruiken

1. Kies Uitvoeren in het menu Start, voer regedit in en selecteer VERVOLGENS OK.

   (U moet beheerdersreferenties hebben om regedit uit te voeren.)

2. Open in de Register-editor de volgende subsleutel: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full. Als de volledige subsleutel niet aanwezig is, hebt u .NET Framework 4.5 of hoger niet geïnstalleerd.

3. Controleer op een REG_DWORD vermelding met de naam Release. Als deze bestaat, hebt u .NET Framework 4.5 of hoger geïnstalleerd. De waarde komt overeen met een bepaalde versie van .NET Framework. In de volgende afbeelding is bijvoorbeeld de waarde van de releasevermelding 528040, de releasesleutel voor .NET Framework 4.8.

   

PowerShell gebruiken om te controleren op een minimale versie

Gebruik PowerShell-opdrachten om de waarde van de releasevermelding van de HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full subsleutel te controleren.

In de volgende voorbeelden wordt de waarde van de releasevermelding gecontroleerd om te bepalen of .NET Framework 4.6.2 of hoger is geïnstalleerd. Deze code retourneert True als deze is geïnstalleerd en False anders.

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

Query's uitvoeren op het register met behulp van code

1. Gebruik de RegistryKey.OpenBaseKey en RegistryKey.OpenSubKey methoden voor toegang tot de HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full-subsleutel in het Windows-register.

   Belangrijk

   Als de app die u uitvoert 32-bits is en wordt uitgevoerd in 64-bits Windows, zijn de registerpaden anders dan eerder vermeld. Het 32-bits register is beschikbaar in de subsleutelHKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\ . De registersubsleutel voor .NET Framework 4.5 is bijvoorbeeld HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\NET Framework Setup\NDP\v4\Full.

2. Controleer de waarde van release REG_DWORD om de geïnstalleerde versie te bepalen. Als u voorwaarts compatibel wilt zijn, controleert u op een waarde die groter is dan of gelijk is aan de waarde die vermeld staat in de .NET Framework-versietabel.

In het volgende voorbeeld wordt de waarde van de releasevermelding in het register gecontroleerd om de versies van .NET Framework 4.5-4.8.1 te vinden die zijn geïnstalleerd.

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

In het voorbeeld ziet u uitvoer zoals hieronder:

.NET Framework Version: 4.6.1

Query's uitvoeren op het register met behulp van PowerShell

In het volgende voorbeeld wordt PowerShell gebruikt om de waarde van de releasevermelding in het register te controleren om de versies van .NET Framework 4.5-4.8.1 te vinden die zijn geïnstalleerd:

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

Dit voorbeeld volgt de aanbevolen procedure voor versiecontrole:

• Er wordt gecontroleerd of de waarde van de releasevermeldinggroter is dan of gelijk is aan de waarde van de bekende releasewaarden.
• Het controleert in volgorde van de meest recente versie naar de vroegste versie.

.NET Framework 1.0-4.0

Elke versie van .NET Framework van 1.1 tot en met 4.0 wordt vermeld als een subsleutel op HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP. De volgende tabel bevat het pad naar elke .NET Framework-versie. Voor de meeste versies is er een installatie-REG_DWORD waarde om 1 aan te geven dat deze versie is geïnstalleerd. In deze subsleutels is er ook een versie-REG_SZ-waarde die een versietekenreeks bevat.

U ziet dat het registerpad naar de subsleutel .NET Framework 1.0 verschilt van de andere.

Register-editor gebruiken (oudere frameworkversies)

1. Kies Uitvoeren in het menu Start, voer regedit in en selecteer VERVOLGENS OK.

   U moet beheerdersreferenties hebben om regedit uit te voeren.

2. Open de subsleutel die overeenkomt met de versie die u wilt controleren. Gebruik de tabel in de sectie .NET Framework 1.0-4.0 .

   In de volgende afbeelding ziet u de subsleutel en de bijbehorende versiewaarde voor .NET Framework 3.5.

   

Query's uitvoeren op het register met behulp van code (oudere frameworkversies)

Gebruik de Microsoft.Win32.RegistryKey klasse voor toegang tot de subsleutelHKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP in het Windows-register.

In het volgende voorbeeld worden de versies van .NET Framework 1-4 gevonden die zijn geïnstalleerd:

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

In het voorbeeld wordt uitvoer weergegeven die vergelijkbaar is met de volgende:

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

Een query uitvoeren op het register met behulp van PowerShell (oudere frameworkversies)

In het volgende voorbeeld wordt PowerShell gebruikt om de waarde van de releasevermelding in het register te controleren om de versies van .NET Framework 1-4 te vinden die zijn geïnstalleerd:

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

Zoek CLR-versies

De .NET Framework CLR die met .NET Framework is geïnstalleerd, wordt afzonderlijk geversied. Er zijn twee manieren om de versie van .NET Framework CLR te detecteren:

• Het hulpprogramma Clrver.exe
• De Environment.Version eigenschap

Het hulpprogramma Clrver.exe

Gebruik het clr-versieprogramma (Clrver.exe) om te bepalen welke versies van de CLR op een computer zijn geïnstalleerd. Open de Opdrachtprompt voor Visual Studio Developer of Visual Studio Developer PowerShell en voer dit in clrver.

Voorbeelduitvoer:

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

De eigenschap Environment.Version

1. Voer een query uit op de Environment.Version eigenschap om een Version object op te halen.

   Het geretourneerde System.Version object identificeert de versie van de runtime die momenteel de code uitvoert. Er worden geen assemblyversies of andere versies van de runtime geretourneerd die mogelijk op de computer zijn geïnstalleerd.

   Voor .NET Framework-versies 4, 4.5, 4.5.1 en 4.5.2 heeft de tekenreeksweergave van het geretourneerde Version object de vorm 4.0.30319.xxxxx, waarbij xxxxx kleiner is dan 42000. Voor .NET Framework 4.6 en latere versies heeft het de vorm 4.0.30319.42000.

2. Nadat u het versieobject hebt, voert u een query uit als volgt:

   • Gebruik de eigenschap voor de primaire release-id (bijvoorbeeld Version.Major voor versie 4.0).
   • Gebruik de eigenschap voor de secundaire release-id (bijvoorbeeld Version.Minor voor versie 4.0).
   • Gebruik de methode voor de volledige versietekenreeks (bijvoorbeeld Version.ToString). Deze methode retourneert één waarde die overeenkomt met de versie van de runtime die de code uitvoert. Er worden geen assemblyversies of andere runtimeversies geretourneerd die mogelijk op de computer zijn geïnstalleerd.

In het volgende voorbeeld wordt de Environment.Version eigenschap gebruikt om CLR-versiegegevens op te halen:

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

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

In het voorbeeld wordt uitvoer weergegeven die vergelijkbaar is met de volgende:

Version: 4.0.30319.18010

Zie ook

• Procedure: Bepalen welke .NET Framework-updates zijn geïnstalleerd
• Problemen oplossen: bepalen welke versies en servicepacks van .NET Framework zijn geïnstalleerd
• .NET Framework installeren voor ontwikkelaars
• .NET Framework-versies en -afhankelijkheden