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

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

• Si vous souhaitez vérifier les versions sur votre propre ordinateur, le moyen le plus simple consiste à utiliserles programmes>et fonctionnalités du > de configuration, ou dans Paramètres sous Applications>installées. Vous pouvez également utiliser ces outils gérés par la communauté.
• Si vous êtes développeur d’applications, vous devrez peut-être savoir quelles versions du .NET Framework sont installées sur l’ordinateur de l’utilisateur de l’application. Le Registre contient une liste des versions de .NET Framework installées sur l’ordinateur. Vous pouvez également interroger la RuntimeInformation.FrameworkDescription propriété.
• Pour rechercher la version CLR, qui est versionnée séparément, consultez Rechercher des versions CLR.

.NET Framework se compose de deux composants principaux, qui sont versionnés séparément :

• Un ensemble d'assemblies, qui sont des collections de types et de ressources fournissant des fonctionnalités à vos applications. .NET Framework et les assemblys partagent le même numéro de version. Par exemple, les versions de .NET Framework incluent 4.5, 4.6.1 et 4.7.2.
• Common Language Runtime (CLR), qui gère et exécute le code de votre application. Une version CLR unique prend généralement en charge plusieurs versions de .NET Framework. Par exemple, CLR version 4.0.30319. xxxxx où xxxxx est inférieur à 42000, prend en charge .NET Framework versions 4 à 4.5.2. La version CLR supérieure ou égale à 4.0.30319.42000 prend en charge les versions de .NET Framework à partir de .NET Framework 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 de .NET Framework installées :

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

Propriété RuntimeInformation.FrameworkDescription

Pour interroger par programmation la version de .NET sur laquelle votre application s’exécute, vous pouvez utiliser la RuntimeInformation.FrameworkDescription propriété. Si l’application s’exécute sur .NET Framework, la sortie est similaire à :

.NET Framework 4.8.4250.0

Par comparaison, si l’application s’exécute sur .NET Core ou .NET 5+, la sortie est similaire à :

.NET Core 3.1.9
.NET 5.0.0

Registry

Vous pouvez utiliser le Registre pour détecter la version de .NET Framework 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 le code pour vérifier le Registre.

• .NET Framework 4.5 et versions ultérieures
  • Éditeur de Registre
  • Interroger à l’aide du code
  • Interroger à l’aide de PowerShell
• .NET Framework 1.0-4.0
  • Éditeur de Registre
  • Interroger à l’aide du code
  • Interroger à l’aide de PowerShell

.NET Framework 4.5 et versions ultérieures

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

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, recherchez une valeur release REG_DWORD supérieure ou égale à la valeur correspondante répertoriée dans le tableau suivant. Par exemple, si votre application s’exécute sous .NET Framework 4.8 ou une version ultérieure, testez une valeur release REG_DWORD supérieure ou égale à 528040.

Utiliser l’éditeur de Registre

1. Dans le menu Démarrer , choisissez Exécuter, entrez regedit, puis sélectionnez OK.

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

2. Dans l’Éditeur du Registre, ouvrez la sous-clé suivante : HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full. Si la sous-clé complète n’est pas présente, vous n’avez pas installé .NET Framework 4.5 ou version ultérieure.

3. Recherchez une entrée REG_DWORD nommée Release. S’il existe, vous avez installé .NET Framework 4.5 ou version ultérieure. Sa valeur correspond à une version particulière de .NET Framework. Dans la figure suivante, par exemple, la valeur de l’entrée release est 528040, qui est la clé de mise en production pour .NET Framework 4.8.

   

Utiliser PowerShell pour rechercher une version minimale

Utilisez les 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 version ultérieure est installé. Ce code retourne True s’il est installé et False sinon.

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

Interroger le Registre à l’aide 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 l’application que vous exécutez est 32 bits et s’exécute dans Windows 64 bits, les chemins d’accès au Registre sont différents de ceux répertoriés précédemment. Le registre 32 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 avec les versions futures, recherchez une valeur supérieure ou égale à la valeur répertoriée dans la table des versions de .NET Framework.

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

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

L’exemple affiche la sortie comme suit :

.NET Framework Version: 4.6.1

Interroger le Registre à l’aide de PowerShell

L’exemple suivant utilise PowerShell pour vérifier la valeur de l’entrée Release dans le Registre pour rechercher les versions de .NET Framework 4.5-4.8.1 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 pour la vérification de version :

• Elle vérifie si la valeur de l’entrée Release est supérieure ou égale à la valeur des valeurs de mise en production connues.
• Il vérifie dans l’ordre entre la version la plus récente et 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é à HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP. Le tableau suivant répertorie le chemin d’accès à chaque version de .NET Framework. Pour la plupart des versions, il existe une valeur d’installation REG_DWORD pour 1 indiquer que cette version est installée. Dans ces sous-clés, il existe également une valeur REG_SZ version 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. Dans le menu Démarrer , choisissez Exécuter, entrez regedit, puis sélectionnez OK.

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

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

   La figure suivante montre la sous-clé et sa valeur version pour .NET Framework 3.5.

   

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

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

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

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

L’exemple affiche une sortie similaire à 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 à l’aide de PowerShell (versions antérieures de l’infrastructure)

L’exemple suivant utilise PowerShell pour vérifier la valeur de l’entrée Release dans le Registre pour rechercher les versions de .NET Framework 1-4 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-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)"
                }
            }
        }
    }
}

Rechercher 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 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 Environment.Version propriété pour récupérer un Version objet.

   L’objet retourné System.Version identifie la version du runtime qui exécute actuellement le code. Il ne retourne pas les versions d’assembly ou d’autres versions du runtime qui ont peut-être été installées sur l’ordinateur.

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

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

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

L’exemple suivant utilise la Environment.Version propriété 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 similaire à ce qui suit :

Version: 4.0.30319.18010

Voir aussi

• Guide pratique pour déterminer les mises à jour du .NET Framework installées
• Résoudre les problèmes : déterminer les versions et les service packs de .NET Framework installés
• Installer .NET Framework pour les développeurs
• Versions et dépendances du .NET Framework