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

Os usuários podem instalar e executar várias versões do .NET Framework em seus computadores. Ao desenvolver ou implantar seu aplicativo, talvez seja necessário saber quais .NET Framework estão instaladas no computador do usuário. O Registro contém uma lista das versões .NET Framework instaladas no computador.

Observação

Este artigo é específico para .NET Framework. Para determinar quais SDKs e runtimes do .NET Core e do .NET 5+ estão instalados, consulte Como verificar se o .NET já está instalado.

.NET Framework consiste em dois componentes principais, que têm a versão separada:

  • Um conjunto de assemblies que são coleções de tipos e recursos que fornecem a funcionalidade para os aplicativos. .NET Framework e os 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 .NET Framework versões 4 a 4.5.2. A versão CLR maior ou igual a 4.0.30319.42000 dá suporte .NET Framework versões do .NET Framework 4.6.

Community ferramentas mantidas pelo .NET Framework estão disponíveis para ajudar a detectar quais .NET Framework estão instaladas:

Para obter informações sobre como detectar as atualizações instaladas para cada versão do .NET Framework, consulte Como determinar quais atualizações .NET Framework estão instaladas.

Determinar em qual implementação e versão do .NET um aplicativo está em execução

Você pode usar a propriedade RuntimeInformation.FrameworkDescription para consultar em qual implementação e versão do .NET seu aplicativo está em execução. Se o aplicativo estiver em execução .NET Framework, a saída será semelhante a:

.NET Framework 4.8.4250.0

Por 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

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

Observação

A sub-chave de Instalação do NET Framework no caminho do Registro não começa com um ponto.

O valor REG_DWORD versão no Registro representa a versão do .NET Framework instalado.

Versão do .NET Framework Valor da versão
.NET Framework 4.5 Todos Windows sistemas operacionais: 378389
.NET Framework 4.5.1 No Windows 8.1 e Windows Server 2012 R2: 378675
Em todos os outros Windows sistemas operacionais: 378758
.NET Framework 4.5.2 Todos Windows sistemas operacionais: 379893
.NET Framework 4.6 No Windows 10: 393295
Em todos os outros Windows sistemas operacionais: 393297
.NET Framework 4.6.1 Em sistemas com a Atualização de novembro do Windows 10: 394254
Em todos os outros Windows operacionais (incluindo Windows 10): 394271
.NET Framework 4.6.2 Na Atualização de Aniversário do Windows 10 e Windows Server 2016: 394802
Em todos os outros Windows operacionais (incluindo outros Windows 10 operacionais): 394806
.NET Framework 4.7 No Windows 10 Creators Update: 460798
Em todos os outros Windows operacionais (incluindo outros Windows 10 operacionais): 460805
.NET Framework 4.7.1 No Windows 10 Fall Creators Update e Windows Server, versão 1709: 461308
Em todos os outros Windows operacionais (incluindo outros Windows 10 operacionais): 461310
.NET Framework 4.7.2 Na Windows 10 de abril de 2018 e Windows Server, versão 1803: 461808
Em todos Windows sistemas operacionais diferentes Windows 10 atualização de abril de 2018 e Windows Server, versão 1803: 461814
.NET Framework 4.8 Na Atualização de maio de 2019 para o Windows 10 e Windows 10 de novembro de 2019: 528040
Na Windows 10 de maio de 2020 atualização e Windows 10 de outubro de 2020 e atualização Windows 10 maio de 2021: 528372
No Windows 11 e Windows Server 2022: 528449
Em todos os outros Windows operacionais (incluindo outros Windows 10 operacionais): 528049

Versão mínima

Para determinar se uma versão mínima do .NET Framework está presente, verifique se há um valor REG_DWORD versão que seja maior ou igual ao valor correspondente listado na tabela a seguir. Por exemplo, se seu aplicativo for executado no .NET Framework 4.8 ou 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

Usar o Editor do Registro

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

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

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

  3. Verifique se há uma REG_DWORD chamada Release. Se ele existir, você terá .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 Release é 528040, que é a chave de liberação para .NET Framework 4.8.

    Registry entry for .NET Framework 4.5

Usar o PowerShell para verificar se há 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 Versão para determinar se .NET Framework 4.6.2 ou posterior está instalado. Esse código retornará True se ele estiver instalado; caso contrário, retornará False.

(Get-ItemProperty "HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full").Release -ge 394802

Consultar o registro usando código

  1. Use os métodos RegistryKey.OpenBaseKey e RegistryKey.OpenSubKey para acessar a subchave RegistryKey.OpenBaseKey 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 64 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 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 de versão no registro para localizar as versões do .NET Framework 4.5-4.8 instaladas.

Dica

Adicione a diretiva using Microsoft.Win32 ou Imports Microsoft.Win32 na parte superior do seu arquivo de código, caso ainda não tenha 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 >= 528040)
        return "4.8 or later";
    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 >= 528040 Then
        Return "4.8 or later"
    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 uma saída semelhante à seguinte:

.NET Framework Version: 4.6.1

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.

detectar .NET Framework 1,0 a 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 de .NET Framework. Para a maioria das versões, há um valor de REG_DWORD de instalação de para indicar que esta versão está instalada. Nessas subchaves, há também uma versão REG_SZ valor que contém uma cadeia de caracteres de versão.

Observação

A subchave de instalação do NET Framework 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 Instalar o REG_SZ igual a
1,1 HKLM\Software\Microsoft\NET Framework Setup\NDP\v1.1.4322 Instalar o REG_DWORD igual a
2,0 HKLM\Software\Microsoft\NET Framework Setup\NDP\v2.0.50727 Instalar o REG_DWORD igual a
3,0 HKLM\Software\Microsoft\NET Framework Setup\NDP\v3.0\Setup InstallSuccess REG_DWORD igual a
3,5 HKLM\Software\Microsoft\NET Framework Setup\NDP\v3.5 Instalar o REG_DWORD igual a
4,0 perfil do cliente HKLM\Software\Microsoft\NET Framework Setup\NDP\v4\Client Instalar o REG_DWORD igual a
4,0 perfil completo HKLM\Software\Microsoft\NET Framework Setup\NDP\v4\Full Instalar o REG_DWORD igual a

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 64 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 mais antigas do Framework)

  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 detectar .NET Framework 1,0 a 4,0 .

    a figura a seguir mostra a subchave e seu valor de versão para .NET Framework 3,5.

    The registry entry for .NET Framework 3.5.

Consultar o registro usando código (versões mais antigas do Framework)

Use a Microsoft.Win32.RegistryKey classe para acessar a subchave Microsoft.Win32.RegistryKey no registro 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 64 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 exemplo a seguir localiza as versões do .NET Framework 1-4 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

Encontrar versões do CLR

o .NET Framework CLR instalado com .NET Framework tem controle de versão separadamente. há duas maneiras de detectar a versão do .NET Framework CLR:

  • A ferramenta de 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 Visual Studio Prompt de Comando do Desenvolvedor ou Visual Studio o PowerShell para desenvolvedores e insira .

    Saída de exemplo:

    Versions installed on the machine:
    v2.0.50727
    v4.0.30319
    
  • A classe

    Importante

    para .NET Framework 4,5 e versões posteriores, não use a Environment.Version propriedade para detectar a versão do CLR. em vez disso, consulte o registro conforme descrito em detectar .NET Framework 4,5 e versões 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.

      para .NET Framework versões 4, 4,5, 4.5.1 e 4.5.2, a representação de cadeia de caracteres do objeto retornado Version tem o formato 4.0.30319.Version, em que xxxxx é menor que 42000. para .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 seguinte:

      • Para o identificador de versão principal (por exemplo, 4 para a versão 4.0), use a propriedade .

      • Para o identificador de versão secundária (por exemplo, 0 para a versão 4.0), use a propriedade .

      • Para a cadeia de caracteres de versão inteira (por exemplo, 4.0.30319.18010), use o 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 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