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 é através de Programas>e Recursos do Painel 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 precise 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 do CLR, que é versionada separadamente, consulte Localizar versões do CLR.

O .NET Framework consiste em dois componentes principais, que são versionados separadamente:

• Um conjunto de assemblies, que são coleções de tipos e recursos que fornecem a funcionalidade 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 Common Language Runtime (CLR), que gerencia e executa o código do seu aplicativo. Uma única versão do CLR normalmente suporta várias versões do .NET Framework. Por exemplo, CLR versão 4.0.30319.xxxxx onde xxxxx é menor que 42000, suporta .NET Framework versões 4 a 4.5.2. A versão do CLR maior ou igual a 4.0.30319.42000 oferece suporte a versões do .NET Framework começando com o .NET Framework 4.6.

Ferramentas mantidas pela comunidade

Ferramentas mantidas pela comunidade estão disponíveis para ajudar a detetar quais versões do .NET Framework estão instaladas:

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

RuntimeInformation.FrameworkDescription propriedade

Para consultar programaticamente em qual versão do .NET seu aplicativo está sendo executado, você pode usar a RuntimeInformation.FrameworkDescription propriedade. Se o aplicativo estiver sendo executado no .NET Framework, a saída será semelhante a:

.NET Framework 4.8.4250.0

Em comparação, se o aplicativo estiver sendo executado no .NET Core ou .NET 5+, a saída será semelhante a:

.NET Core 3.1.9
.NET 5.0.0

Registo

Você pode usar o registro para detetar qual versão do .NET Framework está instalada. As chaves são diferentes para o .NET Framework 1.0-4.0 e o .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 uma máquina está 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 está instalado.

O valor Release REG_DWORD no Registro 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 Release 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 Release REG_DWORD maior ou igual a 528040.

Usar o Editor do Registro

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

   (Você deve 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 Completa não estiver presente, então você não tem o .NET Framework 4.5 ou posterior instalado.

3. Verifique se há uma entrada REG_DWORD chamada Release. Se existir, então você tem 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 Release é 528040, que é a chave de liberação para o .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 retorna True se estiver instalado ou False não.

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

Consultar o registo utilizando o código

1. Use os RegistryKey.OpenBaseKey métodos 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 é de 32 bits e executado no Windows de 64 bits, os caminhos do Registro serão diferentes dos listados anteriormente. O registo de 32 bits está disponível na subchave HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\ . Por exemplo, a subchave do Registro para o .NET Framework 4.5 é HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\NET Framework Setup\NDP\v4\Full.

2. Verifique o valor Release REG_DWORD para determinar a versão instalada. Para ser compatível com o encaminhamento, 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 localizar 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 (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 saídas como as seguintes:

.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 Release no Registro para localizar 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 verificação de versão:

• Ele verifica se o valor da entrada Release é maior ou igual ao valor das chaves de liberação conhecidas.
• Ele verifica a 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 de Install REG_DWORD para 1 indicar que esta versão está instalada. Nessas subchaves, há também um valor Version REG_SZ que contém uma cadeia de caracteres 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 mais antigas da estrutura)

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

   Você deve 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 .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 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 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 mais antigas da estrutura)

O exemplo a seguir usa o PowerShell para verificar o valor da entrada Release no Registro para localizar 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 CLR do .NET Framework instalado com o .NET Framework é versionado separadamente. Há duas maneiras de detetar a versão do CLR do .NET Framework:

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

A ferramenta Clrver.exe

Use a ferramenta Versão do CLR (Clrver.exe) para determinar quais versões do CLR estão instaladas em um computador. Abra o Visual Studio Developer Command Prompt ou o Visual Studio Developer PowerShell e digite 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 tempo de execução que está executando o código no momento. Ele não retorna versões de assembly ou outras versões do tempo de execução que possam ter sido instaladas no computador.

   Para o .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.xxxxx, em que xxxxx é inferior a 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 Version.Minor propriedade.
   • Para a cadeia de caracteres de versão inteira (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 tempo de execução que está executando o código. Ele não retorna versões de assembly ou outras versões de tempo de execução que podem ser instaladas no computador.

O exemplo a seguir usa a Environment.Version propriedade 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

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