Como determinar quais versões do .NET Framework estão instaladas
Observação
Este artigo é específico para aplicativos .NET Framework. Para determinar quais SDKs e runtimes do .NET Core e .NET 5+ estão instalados, consulte Como verificar se o .NET já está instalado.
Você pode instalar e executar várias versões do .NET Framework em um computador.
- Se você quiser verificar as versões em seu próprio computador, a maneira mais fácil é por meio do Painel de Controle>Programas>Programas e Recursos, ou em Configurações em Aplicativos>Aplicativos instalados. Você também pode usar essas ferramentas mantidas pela comunidade.
- Se você for um desenvolvedor de aplicativo, é necessário saber qual versão do .NET Framework está instalada no computador do usuário do aplicativo. O registro contém uma lista das versões de .NET Framework instaladas no computador. Você também pode consultar a
RuntimeInformation.FrameworkDescriptionpropriedade. - Para localizar a versão de CLR, que é versão separadamente, consulte Localizar versões de CLR.
O .NET Framework consiste em dois componentes principais, que têm o controle de versão feito separadamente:
- Um conjunto de assemblies que são coleções de tipos e recursos que fornecem a funcionalidade para os aplicativos. O .NET Framework e assemblies compartilham o mesmo número de versão. Por exemplo, versões do .NET Framework incluem 4.5, 4.6.1 e 4.7.2.
- O Common Language Runtime (CLR) que gerencia e executa o código dos aplicativos. Uma única versão do CLR geralmente dá suporte a várias versões do .NET Framework. Por exemplo, CLR versão 4.0.30319. xxxxx, em que xxxxx é menor que 42000, dá suporte a versões do .NET Framework 4 a 4.5.2. A versão CLR maior ou igual a 4.0.30319.42000 dá suporte a versões do .NET Framework a partir do .NET Framework 4.6.
Dica
Para saber mais sobre como detectar as atualizações instaladas para cada versão do .NET Framework, veja Como determinar quais atualizações do .NET Framework estão instaladas.
Ferramentas mantidas pela comunidade
As ferramentas mantidas pela comunidade estão disponíveis para ajudar a detectar quais versões do .NET Framework estão instaladas:
Propriedade RuntimeInformation.FrameworkDescription
Para consultar programaticamente em qual versão do .NET seu aplicativo está em execução, você pode usar a propriedade RuntimeInformation.FrameworkDescription. Se o aplicativo estiver em execução no .NET Framework, a saída será semelhante a:
.NET Framework 4.8.4250.0
Em comparação, se o aplicativo estiver em execução no .NET Core ou no .NET 5+, a saída será semelhante a:
.NET Core 3.1.9
.NET 5.0.0
Registro
Você pode usar o registro para detectar qual versão do .NET Framework está instalada. As chaves são diferentes para .NET Framework 1.0-4.0 e .NET Framework 4.5+. Você pode usar o Editor do Registro, o PowerShell ou o código para verificar o registro.
.NET Framework 4.5 e versões posteriores
A versão do .NET Framework (4.5 e posterior) instalada em um computador é listada no registro em HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full. Se a subchave Full estiver ausente, então o .NET Framework 4.5 ou superior não está instalado.
Observação
A subchave NET Framework Setup no caminho do registro não começa com um ponto.
O valor REG_DWORD de Versão no registro representa a versão do .NET Framework instalado.
| Versão do .NET Framework | Valor de versão |
|---|---|
| .NET Framework 4.5 | Todos os sistemas operacionais Windows: 378389 |
| .NET Framework 4.5.1 | No Windows 8.1 e Windows Server 2012 R2: 378675 Em todos os outros sistemas operacionais Windows: 378758 |
| .NET Framework 4.5.2 | Todos os sistemas operacionais Windows: 379893 |
| .NET Framework 4.6 | No Windows 10: 393295 Em todos os outros sistemas operacionais Windows: 393297 |
| .NET Framework 4.6.1 | Em sistemas com a Atualização de novembro do Windows 10: 394254 Em todos os outros sistemas operacionais Windows (incluindo o Windows 10): 394271 |
| .NET Framework 4.6.2 | Na Atualização de Aniversário do Windows 10 e no Windows Server 2016: 394802 Em todos os outros sistemas operacionais Windows (incluindo outros sistemas operacionais Windows 10): 394806 |
| .NET Framework 4.7 | No Windows 10 Creators Update: 460798 Em todos os outros sistemas operacionais Windows (incluindo outros sistemas operacionais Windows 10): 460805 |
| .NET Framework 4.7.1 | No Windows 10 Fall Creators Update e Windows Server, versão 1709: 461308 Em todos os outros sistemas operacionais Windows (incluindo outros sistemas operacionais Windows 10): 461310 |
| .NET Framework 4.7.2 | Na Atualização de abril de 2018 do Windows 10 e no Windows Server, versão 1803: 461808 Em todos os sistemas operacionais Windows diferentes da Atualização de abril de 2018 do Windows 10 e do Windows Server, versão 1803: 461814 |
| .NET Framework 4.8 | Na Atualização de maio de 2019 do Windows 10 e Atualização de novembro de 2019 do Windows 10: 528040 Na Atualização de maio de 2020, Atualização de outubro de 2020, Atualização de maio de 2021, Atualização de novembro de 2021 e Atualização de 2022 do Windows 10: 528372 No Windows 11 e Windows Server 2022: 528449 Em todos os outros sistemas operacionais Windows (incluindo outros sistemas operacionais Windows 10): 528049 |
| .NET Framework 4.8.1 | Na Atualização de 2022 do Windows 11 e Atualização de 2023 do Windows 11: 533320 Todos os outros sistemas operacionais Windows: 533325 |
Versão mínima
Para determinar se uma versão mínima do .NET Framework está presente, verifique se há um valor de versão REG_DWORD maior ou igual ao valor correspondente listado na tabela a seguir. Por exemplo, se seu aplicativo for executado no .NET Framework 4.8 ou em uma versão posterior, teste um valor de versão REG_DWORD que seja maior ou igual a 528040.
| Versão do .NET Framework | Valor mínimo |
|---|---|
| .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 |
Usar o Editor do Registro
No menu Iniciar, escolha Executar, insira regedit e, em seguida, selecione OK.
(Você precisará ter credenciais administrativas para executar o regedit.)
No Editor do Registro, abra a seguinte subchave: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full. Se a subchave Full não estiver presente, você não terá o .NET Framework 4.5 ou posterior instalado.
Verifique se há uma entrada REG_DWORD chamada Versão. Se existir, você terá o .NET Framework 4.5 ou posterior instalado. Seu valor corresponde a uma versão específica do .NET Framework. Na figura a seguir, por exemplo, o valor da entrada de versão é 528040, que é a chave de versão do .NET Framework 4.8.
Usar o PowerShell para verificar uma versão mínima
Use comandos do PowerShell para verificar o valor da entrada Release da subchave HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full.
Os exemplos a seguir verificam o valor da entrada de versão para determinar se o .NET Framework 4.6.2 ou posterior está instalado. Esse código retornará True se ele estiver instalado; caso contrário, retornará False.
(Get-ItemPropertyValue -LiteralPath 'HKLM:SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full' -Name Release) -ge 394802
Consultar o registro usando código
Use os métodos RegistryKey.OpenBaseKey e RegistryKey.OpenSubKey para acessar a subchave HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full no Registro do Windows.
Importante
Se o aplicativo que você está executando for de 32 bits e estiver em execução no Windows de 64 bits, os caminhos do registro serão diferentes dos listados anteriormente. O registro de 32 bits está disponível na subchave HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\. Por exemplo, a subchave do registro para .NET Framework 4.5 é HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\NET Framework Setup\NDP\v4\Full.
Verifique o valor da entrada de versão REG_DWORD para determinar a versão instalada. Para compatibilidade com a versão atual, verifique se há um valor superior ou igual ao valor listado na tabela de versões do .NET Framework.
O exemplo a seguir verifica o valor da entrada Release no Registro para localizar as versões do .NET Framework 4.5 – 4.8.1 instaladas.
Dica
Adicione a diretiva using Microsoft.Win32 ou Imports Microsoft.Win32 na parte superior do arquivo de código se você ainda não tiver feito isso.
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
O exemplo exibe a saída como a seguinte:
.NET Framework Version: 4.6.1
Consultar o registro usando o PowerShell
O seguinte exemplo usa o PowerShell para verificar o valor da entrada Release no Registro e encontrar as versões do .NET Framework 4.5 – 4.8.1 que estão instaladas:
$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.'
}
Este exemplo segue a prática recomendada para a verificação de versão:
- Ele verifica se o valor da entrada Release é superior ou igual ao valor das chaves de versão conhecidas.
- Ele verifica na ordem da versão mais recente para a versão mais antiga.
.NET Framework 1.0-4.0
Cada versão do .NET Framework de 1.1 a 4.0 é listada como uma subchave em HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP. A tabela a seguir lista o caminho para cada versão do .NET Framework. Para a maioria das versões, há um valor Install REG_DWORD de 1 para indicar que essa versão está instalada. Nessas subchaves, há também um valor Version REG_SZ que contém uma cadeia de caracteres de versão.
Observação
A subchave NET Framework Setup no caminho do registro não começa com um ponto.
| Versão do Framework | Subchave do registro | Valor |
|---|---|---|
| 1.0 | HKLM\Software\Microsoft\.NETFramework\Policy\v1.0\3705 | Install REG_SZ igual a 1 |
| 1,1 | HKLM\Software\Microsoft\NET Framework Setup\NDP\v1.1.4322 | Instalar REG_DWORD igual a 1 |
| 2,0 | HKLM\Software\Microsoft\NET Framework Setup\NDP\v2.0.50727 | Instalar REG_DWORD igual a 1 |
| 3,0 | HKLM\Software\Microsoft\NET Framework Setup\NDP\v3.0\Setup | InstallSuccess REG_DWORD igual a 1 |
| 3,5 | HKLM\Software\Microsoft\NET Framework Setup\NDP\v3.5 | Instalar REG_DWORD igual a 1 |
| 4.0 Perfil do cliente | HKLM\Software\Microsoft\NET Framework Setup\NDP\v4\Client | Instalar REG_DWORD igual a 1 |
| 4.0 Perfil completo | HKLM\Software\Microsoft\NET Framework Setup\NDP\v4\Full | Instalar REG_DWORD igual a 1 |
Importante
Se o aplicativo que você está executando for de 32 bits e estiver em execução no Windows de 64 bits, os caminhos do registro serão diferentes dos listados anteriormente. O registro de 32 bits está disponível na subchave HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\. Por exemplo, a subchave do registro para .NET Framework 3.5 é HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\NET Framework Setup\NDP\v3.5.
Observe que o caminho do registro para a subchave .NET Framework 1.0 é diferente dos outros.
Usar o Editor do Registro (versões de estrutura mais antigas)
No menu Iniciar, escolha Executar, insira regedit e, em seguida, selecione OK.
Você precisará ter credenciais administrativas para executar o REGEDIT.
Abra a subchave que corresponde à versão que você deseja verificar. Use a tabela na seção .NET Framework 1.0-4.0.
A figura a seguir mostra a subchave e seu valor Version para o .NET Framework 3.5.
Consultar o registro usando código (versões de estrutura mais antigas)
Use a classe Microsoft.Win32.RegistryKey para acessar a subchave HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP no registro do Windows.
Importante
Se o aplicativo que você está executando for de 32 bits e estiver em execução no Windows de 64 bits, os caminhos do registro serão diferentes dos listados anteriormente. O registro de 32 bits está disponível na subchave HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\. Por exemplo, a subchave do registro para .NET Framework 3.5 é HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\NET Framework Setup\NDP\v3.5.
O seguinte exemplo localiza as versões 1-4 do .NET Framework que estão instaladas:
// 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
O exemplo exibe uma saída semelhante à seguinte:
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
Consultar o Registro usando o PowerShell (versões de estrutura mais antigas)
O seguinte exemplo usa o PowerShell para verificar o valor da entrada Release no Registro e encontrar as versões do .NET Framework 1 – 4 que estão instaladas:
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)"
}
}
}
}
}
Encontrar versões do CLR
O .NET Framework CLR instalado com .NET Framework tem versão separada. Há duas maneiras de detectar a versão do .NET Framework CLR:
A ferramenta Clrver.exe
Use a ferramenta de Versão do CLR (Clrver.exe) para determinar quais versões do CLR estão instaladas em um computador. Abra o Prompt de Comando do Desenvolvedor do Visual Studio ou PowerShell do Desenvolvedor do Visual Studio e digite clrver.
Saída de exemplo:
Versions installed on the machine:
v2.0.50727
v4.0.30319
A propriedade Environment.Version
Importante
Para o .NET Framework 4.5 e versões posteriores, não use a propriedade Environment.Version para detectar a versão do CLR. Em vez disso, consulte o registro, conforme descrito em Versões do .NET Framework 4.5 e posteriores.
Consulte a propriedade Environment.Version para recuperar um objeto Version.
O objeto
System.Versionretornado identifica a versão do runtime que está executando o código. Ele não retorna versões de assembly nem outras versões do runtime que possam ter sido instaladas no computador.Nas versões 4, 4.5, 4.5.1 e 4.5.2 do .NET Framework, a representação de cadeia de caracteres do objeto Version retornado tem o formato 4.0.30319.xxxxx, em que xxxxx é menor que 42000. Para o .NET Framework 4.6 e versões posteriores, ele tem o formato 4.0.30319.42000.
Depois de ter o objeto Version, consulte-o da seguinte maneira:
- Para o identificador de versão principal (por exemplo, 4 para a versão 4.0), use a propriedade Version.Major.
- Para o identificador de versão secundária (por exemplo, 0 para a versão 4.0), use a propriedade Version.Minor.
- Para a cadeia de caracteres de versão inteira (por exemplo, 4.0.30319.18010), use o método Version.ToString. Esse método retorna um único valor que reflete a versão do runtime que está executando o código. Ele não retorna versões de assembly nem outras versões do runtime que possam ter sido instaladas no computador.
O seguinte exemplo usa a propriedade Environment.Version para recuperar informações de versão do CLR:
Console.WriteLine($"Version: {Environment.Version}");
Console.WriteLine($"Version: {Environment.Version}")
O exemplo exibe uma saída semelhante à seguinte:
Version: 4.0.30319.18010
