Guide pratique pour déterminer les versions du .NET Framework installées

Vous pouvez installer et exécuter plusieurs versions du .NET Framework sur un ordinateur.

• Si vous souhaitez consulter les versions sur votre propre ordinateur, le moyen le plus simple s’effectue via Panneau de configuration>Programmes>Programmes et fonctionnalités, ou dans Paramètres sous Applications>Applications installées. Vous pouvez également utiliser ces outils gérés par la communauté.
• Si vous êtes un développeur d’application, il est possible que vous deviez savoir les versions de .NET Framework qui sont installées sur l’ordinateur de l’utilisateur de l’application. Le registre contient la liste des versions de .NET Framework installées sur l’ordinateur. Vous pouvez également interroger la propriété RuntimeInformation.FrameworkDescription.
• Pour découvrir la version de CLR, dont le contrôle de version est distinct, consultez Identifier les versions du CLR.

Le .NET Framework comporte deux principaux composants, dont les versions sont définies séparément :

• Un jeu d'assemblys, qui correspondent aux collections de types et de ressources qui fournissent les fonctionnalités de vos applications. Le .NET Framework et les assemblys partagent le même numéro de version. Par exemple, 4.5, 4.6.1 et 4.7.2 sont des versions de .NET Framework.
• Le Common Language Runtime (CLR), qui gère et exécute le code de votre application. En règle générale, une version particulière du CLR prend en charge plusieurs versions du .NET Framework. Par exemple, CLR version 4.0.30319. xxxxx où xxxxx est inférieur à 42000, prend en charge les versions 4 à 4.5.2 du .NET Framework. Une version CLR supérieure ou égale à 4.0.30319.42000 prend en charge les versions du .NET Framework à partir de 4.6.

Outils-gérés-par-la-communauté

Les outils gérés par la communauté sont disponibles pour vous aider à détecter les versions du .NET Framework installées :

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

Propriété RuntimeInformation.FrameworkDescription

Pour interroger de manière programmatique la version .NET sur laquelle s’exécute votre application, vous pouvez utiliser la propriété RuntimeInformation.FrameworkDescription. Si l’application s’exécute sur .NET Framework, la sortie est similaire à ce qui suit :

.NET Framework 4.8.4250.0

À titre de comparaison, si l’application s’exécute sur .NET Core ou .NET 5+, la sortie est similaire à ce qui suit :

.NET Core 3.1.9
.NET 5.0.0

Registre

Vous pouvez utiliser le registre pour détecter la version de .NET Framework qui est installée. Les clés sont différentes pour .NET Framework 1.0-4.0 et .NET Framework 4.5+. Vous pouvez utiliser l’Éditeur de registre, PowerShell ou du code pour vérifier le registre.

• .NET Framework 4.5 et versions ultérieures
  • Éditeur du Registre
  • Requête utilisant du code
  • Requête utilisant PowerShell
• .NET Framework 1.0-4.0
  • Éditeur du Registre
  • Requête utilisant du code
  • Requête utilisant PowerShell

.NET Framework 4.5 et versions ultérieures

La version de .NET Framework (4.5 et ultérieure) installée sur un ordinateur est répertoriée dans le Registre sous HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full. Si la sous-clé Complète est manquante, cela signifie que .NET Framework 4.5 ou version ultérieure n’est pas installé.

La valeur Release REG_DWORD dans le Registre représente la version de .NET Framework installée.

Version minimale

Pour déterminer si une version minimale de .NET Framework est présente, vérifiez que la valeur release REG_DWORD est supérieure ou égale à la valeur correspondante répertoriée dans le tableau suivant. Par exemple, si votre application s’exécute sur .NET Framework 4.8 ou une version ultérieure, recherchez une valeur Release REG_DWORD supérieure ou égale à 528040.

Utiliser l’Éditeur du Registre

1. À partir du menu Démarrer, choisissez Exécuter, entrez regedit, puis sélectionnez OK.

   (Vous devez disposer d’informations d’identification d’administrateur pour exécuter regedit.)

2. Dans l’Éditeur de Registre, ouvrez la sous-clé suivante : HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full. Si la sous-clé Full est absente, alors .NET Framework 4.5 ou version ultérieure n’est pas installé.

3. Recherchez une entrée REG_DWORD nommée Release. Si elle existe, alors .NET Framework 4.5 ou des versions ultérieures sont installés. Sa valeur correspond à une version particulière de .NET Framework. Dans l’illustration suivante, par exemple, la valeur de l’entrée Release est 528040, à savoir la clé de version de .NET Framework 4.8.

   

Utiliser PowerShell pour rechercher une version minimale

Utilisez des commandes PowerShell pour vérifier la valeur de l’entrée Release de la sous-clé HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full.

Les exemples suivants vérifient la valeur de l’entrée Release pour déterminer si .NET Framework 4.6.2 ou une version ultérieure sont installés. Ce code retourne True s’il est installé et False dans le cas contraire.

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

Interroger le Registre en utilisant du code

1. Utilisez les méthodes RegistryKey.OpenBaseKey et RegistryKey.OpenSubKey pour accéder à la sous-clé HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full dans le Registre Windows.

   Important

   Si vous utilisez une application 32 bits sur un système Windows 64 bits, les chemins d’accès au Registre sont différents de ceux répertoriés précédemment. Le registre 64 bits est disponible dans la sous-clé HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\. Par exemple, la sous-clé de Registre pour .NET Framework 4.5 est HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\NET Framework Setup\NDP\v4\Full.

2. Vérifiez la valeur Release REG_DWORD pour déterminer la version installée. Pour être compatible, recherchez une valeur supérieure ou égale à la valeur listée dans le tableau des versions du .NET Framework.

L’exemple suivant vérifie la valeur de l’entrée Release dans le Registre pour identifier les versions du .NET Framework 4.5-4.8.1 qui sont installées.

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

L’exemple affiche les éléments suivants :

.NET Framework Version: 4.6.1

Interroger le registre en utilisant PowerShell

L’exemple suivant utilise PowerShell pour vérifier la valeur de l’entrée Release dans le Registre afin d’identifier les versions du .NET Framework 4.5-4.8.1 qui sont installées :

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

Cet exemple suit la pratique recommandée concernant la vérification de version :

• Il vérifie si la valeur de l’entrée Release est supérieure ou égale à la valeur des clés de version connues.
• Il effectue sa vérification en partant de la version la plus récente vers la version la plus ancienne.

.NET Framework 1.0-4.0

Chaque version de .NET Framework de 1.1 à 4.0 est répertoriée comme sous-clé dans HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP. Le tableau suivant répertorie le chemin d’accès à chaque version du .NET Framework. Pour la plupart des versions, il existe une valeur Install REG_DWORD de 1 pour indiquer que cette version est installée. Dans ces sous-clés, il existe également une valeur Version REG_SZ qui contient une chaîne de version.

Notez que le chemin du Registre vers la sous-clé .NET Framework 1.0 est différent des autres.

Utiliser l’Éditeur de Registre (versions antérieures du framework)

1. À partir du menu Démarrer, choisissez Exécuter, entrez regedit, puis sélectionnez OK.

   Vous devez disposer d’informations d’identification d’administrateur pour exécuter regedit.

2. Ouvrez la sous-clé qui correspond à la version que vous souhaitez vérifier. Utilisez le tableau de la section .NET Framework 1.0-4.0.

   La figure suivante illustre la sous-clé et la valeur Version correspondante pour .NET Framework 3.5.

   

Interroger le Registre à l’aide du code (versions antérieures du Framework)

Utilisez la classe Microsoft.Win32.RegistryKey pour accéder à la sous-clé HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP dans le Registre Windows.

L’exemple suivant identifie les versions de .NET Framework 1-4 installées :

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

L’exemple affiche une sortie semblable à ce qui suit :

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

Interroger le Registre en utilisant PowerShell (anciennes versions du .NET Framework)

L’exemple suivant utilise PowerShell pour vérifier la valeur de l’entrée Release dans le Registre afin d’identifier les versions du .NET Framework 1-4 qui sont installées :

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

Identifier les versions du CLR

Le CLR .NET Framework installé avec .NET Framework est versionné séparément. Il existe deux façons de détecter la version du CLR .NET Framework :

• Outil Clrver.exe
• Propriété Environment.Version

Outil Clrver.exe

Utilisez l’outil de version CLR (Clrver.exe) pour déterminer quelles versions du CLR sont installées sur un ordinateur. Ouvrez l’invite de commandes développeur Visual Studio ou Visual Studio Developer PowerShell et entrez clrver.

Exemple de sortie :

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

La propriété Environment.Version

1. Interrogez la propriété Environment.Version pour récupérer un objet Version.

   L’objet System.Version retourné identifie la version du runtime qui est en train d’exécuter le code. Il ne retourne pas les versions d’assembly ni d’autres versions du runtime susceptibles d’avoir été installées sur l’ordinateur.

   Pour les versions 4, 4.5, 4.5.1 et 4.5.2 du .NET Framework, la représentation sous forme de chaîne de l’objet Version retourné a la forme 4.0.30319.xxxxx, où xxxxx est inférieur à 42000. Pour les versions 4.6 et ultérieures du .NET Framework, la forme est 4.0.30319.42000.

2. Une fois que vous avez l’objet Version, interrogez-le comme suit :

   • Pour l’identificateur de la version majeure (par exemple, 4 pour la version 4.0), utilisez la propriété Version.Major.
   • Pour l’identificateur de la version mineure (par exemple, 0 pour la version 4.0), utilisez la propriété Version.Minor.
   • Pour la chaîne de la version entière (par exemple, 4.0.30319.18010), utilisez la méthode Version.ToString. Cette méthode retourne une valeur unique qui reflète la version du runtime qui est en train d’exécuter le code. Elle ne retourne pas les versions d’assembly ni d’autres versions du runtime susceptibles d’être installées sur l’ordinateur.

L’exemple suivant utilise la propriété Environment.Version pour récupérer les informations de version du CLR :

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

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

L’exemple affiche une sortie semblable à ce qui suit :

Version: 4.0.30319.18010

Voir aussi

• Guide pratique pour déterminer les mises à jour .NET Framework installées
• Résolution des problèmes : Déterminer les versions et les Service Packs de .NET Framework qui sont installés
• Installer .NET Framework pour les développeurs
• Versions et dépendances de .NET Framework