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

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 deProgramas e Recursos de> do > de Controle ou em Configurações em Aplicativos>Instalados. Você também pode usar essas ferramentas mantidas pela comunidade.
• Se você for um desenvolvedor de aplicativos, talvez seja necessário saber quais versões do .NET Framework estão instaladas no computador do usuário do aplicativo. O registro contém uma lista das versões do .NET Framework instaladas no computador. Você também pode consultar a RuntimeInformation.FrameworkDescription propriedade.
• Para localizar a versão CLR, que tem uma versão separada, consulte Localizar versões CLR.

O .NET Framework consiste em dois componentes principais, que são separados por versão:

• Um conjunto de assemblies, que são coletâneas de tipos e recursos que oferecem funcionalidades para seus aplicativos. O .NET Framework e os assemblies compartilham o mesmo número de versão. Por exemplo, as versões do .NET Framework incluem 4.5, 4.6.1 e 4.7.2.
• O CLR (Common Language Runtime), que gerencia e executa o código do aplicativo. Uma única versão clr normalmente dá suporte a várias versões do .NET Framework. Por exemplo, CLR versão 4.0.30319. xxxxx ondexxxxx é menor que 42000, dá suporte às versões do .NET Framework 4 a 4.5.2. A versão CLR maior ou igual à 4.0.30319.42000 dá suporte a versões do .NET Framework a partir do .NET Framework 4.6.

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:

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

Propriedade RuntimeInformation.FrameworkDescription

Para consultar programaticamente em qual versão do .NET seu aplicativo está em execução, você pode usar a RuntimeInformation.FrameworkDescription propriedade. 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

Registry

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
  • Editor do Registro
  • Consulta usando código
  • Consulta usando o PowerShell
• .NET Framework 1.0-4.0
  • Editor do Registro
  • Consulta usando código
  • Consulta usando o PowerShell

.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 Completa estiver ausente, o .NET Framework 4.5 ou superior não será instalado.

O valor Release REG_DWORD no registro do Windows representa a versão do .NET Framework instalada.

Versão mínima

Para determinar se uma versão mínima do .NET Framework está presente, verifique se há um valor do tipo REG_DWORD chamado Release que seja maior ou igual ao valor correspondente listado na tabela a seguir. Por exemplo, se o aplicativo for executado no .NET Framework 4.8 ou em uma versão posterior, verifique se há um valor Release REG_DWORD que seja maior do que ou igual a 528040.

Usar o Editor do Registro

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

   (Você deve ter credenciais administrativas para executar regedit.)

2. No Editor do Registro, abra a seguinte subchave: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full. Se a subchave Completa não estiver presente, você não terá o .NET Framework 4.5 ou posterior instalado.

3. Verifique se há uma entrada de REG_DWORD chamada Release. 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 lançamento do .NET Framework 4.8.

   

Usar o PowerShell para verificar uma versão mínima

Use os 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 Release para determinar se o .NET Framework 4.6.2 ou posterior está instalado. Esse código retornará True se ele estiver instalado e False de outra forma.

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

Consultar o registro usando o 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 em execução 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 REG_DWORD de Lançamento para determinar a versão instalada. Para ser compatível com versões futuras, verifique se há um valor maior ou igual ao valor listado na tabela de versão do .NET Framework.

O exemplo a seguir verifica o valor da entrada Release no registro para identificar as versões do .NET Framework 4.5-4.8.1 que estão instaladas.

const string subkey = @"SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full\";

using (RegistryKey baseKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32))
using (RegistryKey ndpKey = baseKey.OpenSubKey(subkey))
{
    if (ndpKey != null && ndpKey.GetValue("Release") != null)
        Console.WriteLine($".NET Framework Version: {CheckFor45PlusVersion((int)ndpKey.GetValue("Release"))}");
    else
        Console.WriteLine(".NET Framework Version 4.5 or later is not detected.");
}

// Checking the version using >= enables forward compatibility.
string CheckFor45PlusVersion(int releaseKey)
{
    if (releaseKey >= 533320) return "4.8.1 or later";
    if (releaseKey >= 528040) return "4.8";
    if (releaseKey >= 461808) return "4.7.2";
    if (releaseKey >= 461308) return "4.7.1";
    if (releaseKey >= 460798) return "4.7";
    if (releaseKey >= 394802) return "4.6.2";
    if (releaseKey >= 394254) return "4.6.1";
    if (releaseKey >= 393295) return "4.6";
    if (releaseKey >= 379893) return "4.5.2";
    if (releaseKey >= 378675) return "4.5.1";
    if (releaseKey >= 378389) return "4.5";

    // This code should never execute. A non-null release key should mean
    // that 4.5 or later is installed.
    return "No 4.5 or later version detected";
}

Private Sub Get45PlusFromRegistry()
    Const subkey As String = "SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full\"

    Using baseKey As RegistryKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32),
          ndpKey As RegistryKey = baseKey.OpenSubKey(subkey)

        If ndpKey IsNot Nothing AndAlso ndpKey.GetValue("Release") IsNot Nothing Then
            Console.WriteLine($".NET Framework Version: {CheckFor45PlusVersion(ndpKey.GetValue("Release"))}")
        Else
            Console.WriteLine(".NET Framework Version 4.5 or later is not detected.")
        End If

    End Using

End Sub

' Checking the version using >= enables forward compatibility.
Private Function CheckFor45PlusVersion(releaseKey As Integer) As String
    Select Case releaseKey
        Case >= 533320 : Return "4.8.1 or later"
        Case >= 528040 : Return "4.8"
        Case >= 461808 : Return "4.7.2"
        Case >= 461308 : Return "4.7.1"
        Case >= 460798 : Return "4.7"
        Case >= 394802 : Return "4.6.2"
        Case >= 394254 : Return "4.6.1"
        Case >= 393295 : Return "4.6"
        Case >= 379893 : Return "4.5.2"
        Case >= 378675 : Return "4.5.1"
        Case >= 378389 : Return "4.5"
        Case Else
            Return "No 4.5 or later version detected"
    End Select
End Function

O exemplo exibe a saída como a seguinte:

.NET Framework Version: 4.6.1

Consultar o registro usando o PowerShell

O exemplo a seguir usa o PowerShell para verificar o valor da entrada de versão no registro para localizar as versões do .NET Framework 4.5-4.8.1 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 verificação de versão:

• Ele verifica se o valor da entrada de versão é maior ou igual ao valor dos valores de versão conhecidos.
• Ele verifica em 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 REG_DWORD de Instalação1 para indicar a instalação desta versão. Nessas subchaves, há também um valor REG_SZ chamado Version que contém uma string de versão.

Observe que o caminho do Registro para a subchave do .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 selecione OK.

   Você deve ter credenciais administrativas para executar 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 de versão para .NET Framework 3.5.

   

Consultar o registro usando código (versões de estrutura mais antigas)

Use a Microsoft.Win32.RegistryKey classe para acessar a subchave HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP no Registro do Windows.

O exemplo a seguir localiza as versões do .NET Framework 1-4 instaladas:

// Open the registry key for the .NET Framework entry. Dispose this object when done.
RegistryKey ndpKey =
    RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32)
        .OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP\");

foreach (string versionKeyName in ndpKey.GetSubKeyNames())
{
    // Skip .NET Framework 4.5 version information.
    if (versionKeyName == "v4")
        continue;

    if (versionKeyName.StartsWith("v"))
    {
        RegistryKey versionKey = ndpKey.OpenSubKey(versionKeyName);

        // Get the .NET Framework version value.
        string name = versionKey.GetValue("Version", "").ToString();

        // Get the service pack (SP) number.
        string sp = versionKey.GetValue("SP", "").ToString();

        // Get the installation flag.
        string install = versionKey.GetValue("Install", "").ToString();

        if (string.IsNullOrEmpty(install))
        {
            // No install info; it must be in a child subkey.
            Console.WriteLine($"{versionKeyName}  {name}");
        }
        else if (install == "1")
        {
            // Install = 1 means the version is installed.
            if (!string.IsNullOrEmpty(sp))
                Console.WriteLine($"{versionKeyName}  {name}  SP{sp}");
            else
                Console.WriteLine($"{versionKeyName}  {name}");
        }

        if (!string.IsNullOrEmpty(name))
        {
            versionKey.Dispose();
            continue;
        }

        // Iterate through the subkeys of the version subkey.
        foreach (string subKeyName in versionKey.GetSubKeyNames())
        {
            RegistryKey subKey = versionKey.OpenSubKey(subKeyName);
            name = subKey.GetValue("Version", "").ToString();

            if (!string.IsNullOrEmpty(name))
                sp = subKey.GetValue("SP", "").ToString();

            install = subKey.GetValue("Install", "").ToString();

            if (string.IsNullOrEmpty(install))
            {
                // No install info; it must be later.
                Console.WriteLine($"  {versionKeyName}  {name}");
            }
            else if (install == "1")
            {
                if (!string.IsNullOrEmpty(sp))
                    Console.WriteLine($"  {subKeyName}  {name}  SP{sp}");
                else
                    Console.WriteLine($"  {subKeyName}  {name}");
            }

            // Clean up the subkey object.
            subKey.Dispose();
        }

        versionKey.Dispose();
    }
}

ndpKey.Dispose();

' Open the registry key for the .NET Framework entry. Dispose this object when done.
Dim ndpKey As RegistryKey =
    RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32) _
        .OpenSubKey("SOFTWARE\Microsoft\NET Framework Setup\NDP\")

For Each versionKeyName In ndpKey.GetSubKeyNames()
    ' Skip .NET Framework 4.5 and later.
    If versionKeyName = "v4" Then Continue For

    If versionKeyName.StartsWith("v") Then

        Dim versionKey As RegistryKey = ndpKey.OpenSubKey(versionKeyName)

        ' Get the .NET Framework version value.
        Dim name = versionKey.GetValue("Version", "").ToString()

        ' Get the service pack (SP) number.
        Dim sp = versionKey.GetValue("SP", "").ToString()

        Dim install = versionKey.GetValue("Install", "").ToString()

        If String.IsNullOrEmpty(install) Then

            ' No install info; it must be in a child subkey.
            Console.WriteLine($"{versionKeyName}  {name}")

        ElseIf install = "1" Then

            ' Install = 1 means the version is installed.
            If Not String.IsNullOrEmpty(sp) Then
                Console.WriteLine($"{versionKeyName}  {name}  SP{sp}")
            Else
                Console.WriteLine($"{versionKeyName}  {name}")
            End If

        End If

        If Not String.IsNullOrEmpty(name) Then

            versionKey.Dispose()
            Continue For

        End If

        ' Iterate through the subkeys of the version subkey.
        For Each subKeyName In versionKey.GetSubKeyNames()

            Dim subKey As RegistryKey = versionKey.OpenSubKey(subKeyName)
            name = subKey.GetValue("Version", "").ToString()

            If Not String.IsNullOrEmpty(name) Then
                sp = subKey.GetValue("SP", "").ToString()
            End If

            install = subKey.GetValue("Install", "").ToString()

            If String.IsNullOrEmpty(install) Then

                ' No install info; it must be later.
                Console.WriteLine($"  {versionKeyName}  {name}")

            ElseIf install = "1" Then

                If Not String.IsNullOrEmpty(sp) Then
                    Console.WriteLine($"  {subKeyName}  {name}  SP{sp}")
                Else
                    Console.WriteLine($"  {subKeyName}  {name}")
                End If

            End If

            ' Clean up the subkey object.
            subKey.Dispose()

        Next

        versionKey.Dispose()

    End If
Next

ndpKey.Dispose()

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 exemplo a seguir usa o PowerShell para verificar o valor da entrada de versão no registro para localizar as versões do .NET Framework 1-4 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)"
                }
            }
        }
    }
}

Localizar versões do CLR

O CLR do .NET Framework instalado tem sua versão separada. Há duas maneiras de detectar a versão do CLR do .NET Framework:

• A ferramenta Clrver.exe
• A Environment.Version propriedade

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 o PowerShell do Desenvolvedor do Visual Studio e insira clrver.

Saída de exemplo:

Versions installed on the machine:
v2.0.50727
v4.0.30319

A Environment.Version propriedade

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

   O objeto retornado System.Version identifica a versão do runtime que está executando o código no momento. Ele não retorna versões de assembly ou outras versões do runtime que podem ter sido instaladas no computador.

   Para as versões 4, 4.5, 4.5.1 e 4.5.2 do .NET Framework, a representação de cadeia de caracteres do objeto retornado Version tem o formulário 4.0.30319.xxxxx, onde 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 Version.Major propriedade.
   • Para o identificador de versão secundária (por exemplo, 0 para a versão 4.0), use a propriedade Version.Minor.
   • Para toda a cadeia de caracteres de versão (por exemplo, 4.0.30319.18010), use o Version.ToString método. 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 ou outras versões de runtime que podem ser instaladas no computador.

O exemplo a seguir usa a Environment.Version propriedade para recuperar informações de versão clr:

Console.WriteLine($"Version: {Environment.Version}");

Console.WriteLine($"Version: {Environment.Version}")

O exemplo exibe uma saída semelhante à seguinte:

Version: 4.0.30319.18010

Consulte também

• Como determinar quais atualizações do .NET Framework estão instaladas
• Solução de problemas: determinar quais versões e service packs do .NET Framework estão instalados
• Instalar o .NET Framework para desenvolvedores
• Versões e dependências do .NET Framework