Compartilhar via

Como determinar quais versões do .NET Framework estão instaladas

  • Artigo

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

  1. No menu Iniciar, escolha Executar, insira regedit e, em seguida, selecione OK.

    (Você precisará ter credenciais administrativas para executar o regedit.)

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

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

    Entrada do registro para .NET Framework 4.5

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

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

  2. 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 é maior ou igual ao valor dos valores de release conhecidos.
  • 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)

  1. No menu Iniciar, escolha Executar, insira regedit e, em seguida, selecione OK.

    Você precisará ter credenciais administrativas para executar o REGEDIT.

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

    A entrada do registro para .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-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)"
                }
            }
        }
    }
}

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.

  1. Consulte a propriedade Environment.Version para recuperar um objeto Version.

    O objeto System.Version retornado 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.

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

Confira também