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

Les utilisateurs peuvent installer et exécuter plusieurs versions du .NET Framework sur leurs ordinateurs. Quand vous développez ou déployez votre application, vous pouvez avoir besoin de savoir quelles versions de .NET Framework sont installées sur l’ordinateur de l’utilisateur. Le Registre contient la liste des versions de .NET Framework installées sur l’ordinateur.

Notes

Cet article est spécifique au .NET Framework. Pour déterminer quels kits SDK et SDK .NET Core et .NET 5+ sont installés, consultez Comment vérifier que .NET est déjà installé.

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. xxxxxxxxxx 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.

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

Pour plus d’informations sur la détection des mises à jour installées pour chaque version du .NET Framework, consultez Guide pratique pour déterminer les mises à jour .NET Framework installées.

Déterminer l’implémentation et la version .NET sur lesquelles est exécutée une application

Vous pouvez utiliser la propriété RuntimeInformation.FrameworkDescription pour interroger l’implémentation et la version de .NET sur lesquelles votre application s’exécute. 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

Détecter .NET Framework versions 4.5 et 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é.

Notes

La sous-clé NET Framework Setup du Registre ne commence pas par un point.

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

Version du .NET Framework Valeur de Release
.NET Framework 4.5 Tous les systèmes d’exploitation Windows : 378389
.NET Framework 4.5.1 Sous Windows 8.1 et Windows Server 2012 R2 : 378675
Sur tous les autres systèmes d’exploitation Windows : 378758
.NET Framework 4.5.2 Tous les systèmes d’exploitation Windows : 379893
.NET Framework 4.6 Sous Windows 10 : 393295
Sur tous les autres systèmes d’exploitation Windows : 393297
.NET Framework 4.6.1 Sur les systèmes Windows intégrant la mise à jour du 10 novembre : 394254
Sur tous les autres systèmes d’exploitation Windows (y compris Windows 10) : 394271
.NET Framework 4.6.2 Sur les systèmes Mise à jour anniversaire Windows 10 et Windows Server 2016 : 394802
Sur tous les autres systèmes d’exploitation Windows (y compris d’autres systèmes d’exploitation Windows 10) : 394806
.NET Framework 4.7 Sur Windows 10 Creators Update : 460798
Sur tous les autres systèmes d’exploitation Windows (y compris d’autres systèmes d’exploitation Windows 10) : 460805
.NET Framework 4.7.1 Sur Windows 10 Fall Creators Update et Windows Server, version 1709 : 461308
Sur tous les autres systèmes d’exploitation Windows (y compris d’autres systèmes d’exploitation Windows 10) : 461310
.NET Framework 4.7.2 Sur Windows 10 avec la mise à jour d’avril 2018 et Windows Server, version 1803 : 461808
Sur tous les systèmes d’exploitation Windows autres que la mise à jour d’avril 2018 de Windows 10 et la version 1803 de Windows Server : 461814
.NET Framework 4.8 Sur Windows 10 avec la mise à jour de mai 2019 et Windows 10 avec la mise à jour de novembre 2019 : 528040
Sur Windows 10 Mise à jour de mai 2020, Mise à jour d’octobre 2020, Mise à jour de mai 2021, Mise à jour de novembre 2021 et Mise à jour 2022 : 528372
Sous Windows 11 et Windows Server 2022 : 528449
Sur tous les autres systèmes d’exploitation Windows (y compris d’autres systèmes d’exploitation Windows 10) : 528049
.NET Framework 4.8.1 Lors de la mise à jour Windows 11 2022 : 533320
Tous les autres systèmes d’exploitation Windows : 533325

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.

Version du .NET Framework Valeur minimale
.NET Framework 4.5 378389
.NET Framework 4.5.1 378675
.NET Framework 4.5.2 379893
.NET Framework 4.6 393295
.NET Framework 4.6.1 394254
.NET Framework 4.6.2 394802
.NET Framework 4.7 460798
.NET Framework 4.7.1 461308
.NET Framework 4.7.2 461808
.NET Framework 4.8 528040
.NET Framework 4.8.1 533320

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.

    Entrée du Registre pour .NET Framework 4.5

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.

Conseil

Ajoutez la directive using Microsoft.Win32 ou Imports Microsoft.Win32 en haut de votre fichier de code si vous ne l’avez pas déjà fait.

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.

Détecter .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.

Notes

La sous-clé NET Framework Setup du Registre ne commence pas par un point.

Version du Framework Sous-clé de Registre Valeur
1.0 HKLM\Software\Microsoft\.NETFramework\Policy\v1.0\3705 Install REG_SZ est égal à 1
1,1 HKLM\Software\Microsoft\NET Framework Setup\NDP\v1.1.4322 Install REG_DWORD est égal à 1
2.0 HKLM\Software\Microsoft\NET Framework Setup\NDP\v2.0.50727 Install REG_DWORD est égal à 1
3.0 HKLM\Software\Microsoft\NET Framework Setup\NDP\v3.0\Setup InstallSuccess REG_DWORD est égal à 1
3,5 HKLM\Software\Microsoft\NET Framework Setup\NDP\v3.5 Install REG_DWORD est égal à 1
Profil client 4.0 HKLM\Software\Microsoft\NET Framework Setup\NDP\v4\Client Install REG_DWORD est égal à 1
Profil complet 4.0 HKLM\Software\Microsoft\NET Framework Setup\NDP\v4\Full Install REG_DWORD est égal à 1

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 3.5 est HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\NET Framework Setup\NDP\v3.5.

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 Détecter .NET Framework 1.0 à 4.0.

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

    Entrée de Registre 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.

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 3.5 est HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\NET Framework Setup\NDP\v3.5.

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

    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 classe Environment

    Important

    Pour .NET Framework versions 4.5 et ultérieures, n’utilisez pas la propriété Environment.Version pour détecter la version du CLR. Interrogez plutôt le Registre comme décrit dans Détecter les versions 4.5 et ultérieures du .NET Framework avec du code.

    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