Guide pratique pour déterminer les versions du .NET Framework installées
Remarque
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é.
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.
Conseil
Pour obtenir 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.
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 :
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
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 | Sur 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 avec la mise à jour de mai 2020, la mise à jour d’octobre 2020, la mise à jour de mai 2021, la mise à jour de novembre 2021 et la mise à jour de 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 | Sur Windows 11 avec la mise à jour 2022 et Windows 11 avec la mise à jour 2023 : 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
À 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.)
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é.
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
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.
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.
.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)
À 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.
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.
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 propriété Environment.Version
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 .NET Framework 4.5 et versions ultérieures.
Interrogez la propriété Environment.Version pour récupérer un objet Version.
L’objet
System.Versionretourné 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.
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
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour