Qual é a maneira infalível de saber quais versões do .NET estão instaladas em um Windows Server de produção?


99

Esta questão não está muito relacionada à programação, mas à implantação.

Pego-me conversando muito com o grupo em minha empresa cujo trabalho é manter nossos servidores Windows de produção e implantar nosso código neles. Por motivos legais e de conformidade, não tenho visibilidade direta ou qualquer controle sobre os servidores, então a única maneira de saber quais versões do .NET estão instaladas em qualquer um deles é por meio de instruções que dou a esse grupo.

Até agora, todos os métodos que posso pensar para dizer quais versões estão instaladas (verifique se há ferramentas administrativas correspondentes a 1.1 ou 2.0, verifique as entradas na lista "Adicionar / remover programas", verifique a existência de diretórios em c: \ Windows \ Microsoft.NET) são falhos (eu vi pelo menos uma máquina com 2.0, mas nenhuma entrada 2.0 em Ferramentas Administrativas - e esse método não diz nada sobre 3.0+, a lista "Adicionar / Remover Programas" pode ficar fora de sincronia com a realidade, e a existência dos diretórios não significa necessariamente nada).

Dado que geralmente preciso saber que essas coisas estão em vigor com antecedência (descobrir que "opa, este não tem todas as versões e service packs de que você precisa" não funciona bem com janelas de manutenção curtas) e eu tenho que faço a verificação "por proxy", já que não consigo acessar os servidores diretamente, qual é a maneira infalível de saber quais versões do .NET estão instaladas em um Windows Server de produção? De preferência, alguma maneira intrínseca de fazer isso usando o que o framework instala, já que será mais rápido e não precisará de algum tipo de utilitário para ser carregado e também um método que definitivamente irá falhar se os frameworks não estiverem instalados corretamente, mas ainda tiverem arquivos no lugar , há um diretório e gacutil.exe está localizado lá, mas essa versão da estrutura não está realmente "instalada")

EDITAR: Na ausência de uma boa maneira intrínseca à prova de falhas para fazer isso embutido no (s) Framework (s), alguém conhece um programa bom, leve e sem instalação necessária que possa descobrir isso? Posso imaginar que alguém poderia escrever um facilmente, mas se já existir, seria ainda melhor.


1
Eu pesquisei isso um tempo atrás e não consegui encontrar uma maneira definitiva de fazer isso. Eu ficaria interessado em ver que respostas obteremos.
Kev

Possível duplicata de Como detectar quais versões do .NET Framework e service packs estão instalados? - a questão canônica (embora seja 17 dias mais jovem).
Peter Mortensen

Respostas:


54

Você deve abrir o IE no servidor para o qual está procurando essas informações e ir a este site: http://www.hanselman.com/smallestdotnet/

Isso é tudo o que preciso.

O site tem um script que procura o "UserAgent" do seu navegador e descobre qual versão (se houver) do .NET Framework você instalou (ou não) e o exibe automaticamente (então calcula o tamanho total se você escolher para baixar o .NET Framework).


19
- se for um servidor de produção, ele pode nem ter acesso a ele - navegar em sites aleatórios no servidor prod é uma grande desvantagem - esse site fornece apenas a versão mais alta .Net; ele quer todos eles
Franci Penov

1
O problema com essa abordagem é que ela apenas informa qual é a versão mais recente que você tem. Eu implanto código em 2.0, 3.0, 3.5 e (infelizmente) até 1.1. Embora o objetivo seja fazer com que tudo seja atualizado eventualmente, o triste fato por agora é que preciso de todas as diferentes versões paralelas.
Tom Kidd

1
Embora eu concorde que esta solução pode não ser apropriada para servidores de produção, eu votei a favor porque é certamente o método mais simples e rápido para máquinas de desenvolvimento (nas quais eu o usei com frequência). A versão atual do script detectou com êxito todas as diferentes versões do .NET que instalei.
kmote

Sequência do agente do usuário no URL fornecido: Mozilla / 5.0 (compatível; MSIE 10.0; Windows NT 6.1; WOW64; Trident / 6.0) . Bu-ga-ga, então, quais versões do .NET Framework estão instaladas? Para alcançar o resultado esperado, é necessário mudar o IE para o modo compatível.
Mosc

1
Scott Hanselman certamente estabeleceu sua boa-fé, então eu não o chamaria de "site aleatório". (Além disso, ele disponibiliza o código-fonte.) Mas este aplicativo requer uma conexão com a Internet, que os hosts presos em uma gaiola de Faraday freqüentemente não têm.
Robert Calhoun

24

Você pode verificar programaticamente o registro e algumas outras coisas de acordo com esta entrada do blog .

A chave de registro a ser examinada é

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\...]

Não sei dizer - isso também cobre 1.1?
Tom Kidd

1
Posso ver os detalhes 1.1 nesta chave de registro no meu sistema, então diria que cobre 1.1
Niall Connaughton

Sim, olhando em ... \ NDP \ v4 \ Full \, então na versão eu pude ver que tinha a v 4.5.5 ... A TargetVersion é definida como 4.0.0
Off The Gold


15

De acordo com a resposta do CodeTrawler , a solução é inserir o seguinte em uma janela do explorer:

% systemroot% \ Microsoft.NET \ Framework

Em seguida, pesquise:

Mscorlib.dll

... e clique com o botão direito / vá para a guia de versão de cada resultado.


Esta parece ser a maneira mais fácil de diferenciar entre a versão 4 / 4.5+, caso contrário, para uma visão geral do que está instalado, a resposta do @ K.Dias funcionou para mim: dir% windir% \ microsoft.net \ framework \ v * / O : -N / B
Timothy Lee Russell

15

O jeito da Microsoft é este:

MSDN: Como determinar Versões Qual .NET Framework estão instaladas (que direciona para a seguinte chave do registro: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\...)

Se você quer infalível, isso é outra coisa. Eu não me preocuparia com uma xcopy da pasta do framework. Se alguém fizesse isso, eu consideraria o computador quebrado.

A maneira mais infalível seria escrever um pequeno programa que usasse cada versão do .NET e as bibliotecas de seu interesse e executá-las.

Para um método sem instalação, PowerBasic é uma excelente ferramenta. Ele cria pequenos exe's sem tempo de execução necessário. Ele poderia automatizar as verificações descritas no artigo MS KB acima.


Este método não funciona mais para as versões 4.5.1 e superiores
Scott Solmer

@ Okuma.Scott - Eu atualizei o link para as instruções oficiais do MSDN.
kmote


3

Se a máquina que você deseja verificar tem o .NET SDK instalado, você pode usar um prompt de comando do SDK e executar o programa CLRVer.exe.


1
Há algum problema (de licenciamento) com a implantação apenas desse executável? Não tem dependências para falar.

1
clrver é inútil, porque mente. Diz 4.0. * Para 4.5 / 4.6
Roman Starkov


1

A implantação do OneTouch fará toda a detecção e instalação dos pré-requisitos. Provavelmente, é melhor escolher uma solução predefinida do que tentar criar a sua própria. Tentar fazer o seu próprio pode levar a problemas porque tudo o que você digitar pode mudar com um hotfix ou service pack. Provavelmente a Microsoft tem alguma heurística para determinar qual versão está sendo executada.



1

Além disso, consulte a questão Stack Overflow. Como detectar quais versões do .NET Framework e service packs estão instalados? que também menciona:

Há uma resposta oficial da Microsoft para essa pergunta no artigo da base de conhecimento [Como determinar quais versões e níveis de service pack do Microsoft .NET Framework estão instalados] [2]

Artigo: 318785 - Última revisão: quinta-feira, 7 de Novembro de 2008 - Revisão: 20.1 Como determinar quais as versões do .NET Framework instaladas e se os service packs foram aplicados.

Infelizmente, não parece funcionar, porque a mscorlib.dllversão no diretório 2.0 tem uma versão 2.0 e não há nenhuma mscorlib.dllversão nos diretórios 3.0 ou 3.5, embora o 3.5 SP1 esteja instalado ... Por que a resposta oficial da Microsoft seria tão mal informado?


1

Para determinar o suporte do seu servidor para .NET Framework 4.5 e versões posteriores (testado até 4.5.2): Se você não tem acesso ao Registro no servidor , mas tem direitos de publicação de aplicativo para esse servidor, crie um aplicativo MVC 5 com um aplicativo trivial controlador, assim:

using System.Web.Mvc;

namespace DotnetVersionTest.Controllers
{
    public class DefaultController : Controller
    {
        public string Index()
        {
            return "simple .NET version test...";
        }
    }
}

Em seguida, em seu Web.config, percorra as versões desejadas do .NET Framework na seção a seguir, alterando os targetFrameworkvalores conforme desejado:

<system.web>
    <customErrors mode="Off"/>
    <compilation debug="true" targetFramework="4.5.2"/>
    <httpRuntime targetFramework="4.5.2"/>
</system.web>

Publique cada destino em seu servidor e navegue até <app deploy URL>/Default. Se o seu servidor suportar a estrutura de destino, a string simples será exibida no seu Controlador trivial. Caso contrário, você receberá um erro como o seguinte:

Exemplo de .NET 4.5.2 sem suporte no servidor

Portanto, neste caso, meu servidor de destino ainda não oferece suporte ao .NET Framework 4.5.2.


1

Para obter a versão dotnet instalada,
crie um aplicativo de console. Adicionar esta classe Executar isso

using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication2
{
    public class GetDotNetVersion
    {
        public static void Get45PlusFromRegistry()
        {
            const string subkey = @"SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full\";
            using (RegistryKey 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 >= will enable forward compatibility.
        private static string CheckFor45PlusVersion(int releaseKey)
        {
            if (releaseKey >= 394802)
                return "4.6.2 or later";
            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 shoul
            // that 4.5 or later is installed.
            return "No 4.5 or later version detected";
        }
    }
    // Calling the GetDotNetVersion.Get45PlusFromRegistry method produces 
    // output like the following:
    //       .NET Framework Version: 4.6.1
}

versão mais recente 4.7.2?
Kiquenet

0

Estranhamente, escrevi um código para fazer isso quando o 1.1 foi lançado (o que era isso, sete anos atrás?) E o ajustei um pouco quando o 2.0 foi lançado. Não o vejo há anos, pois não gerenciamos mais nossos servidores.

Não é infalível, mas estou postando de qualquer maneira porque acho engraçado; nisso é mais fácil de fazer no .NET e mais fácil ainda no power shell.

bool GetFileVersion(LPCTSTR filename,WORD *majorPart,WORD *minorPart,WORD *buildPart,WORD *privatePart)
{
    DWORD dwHandle;
    DWORD dwLen = GetFileVersionInfoSize(filename,&dwHandle);
    if (dwLen) {
        LPBYTE lpData = new BYTE[dwLen];
        if (lpData) {
            if (GetFileVersionInfo(filename,0,dwLen,lpData)) {
                UINT uLen;  
                VS_FIXEDFILEINFO *lpBuffer;  
                VerQueryValue(lpData,_T("\\"),(LPVOID*)&lpBuffer,&uLen);  
                *majorPart = HIWORD(lpBuffer->dwFileVersionMS);
                *minorPart = LOWORD(lpBuffer->dwFileVersionMS);
                *buildPart = HIWORD(lpBuffer->dwFileVersionLS);
                *privatePart = LOWORD(lpBuffer->dwFileVersionLS);
                delete[] lpData;
                return true;
            }
        }
    }
    return false;
}

int _tmain(int argc,_TCHAR* argv[])
{
    _TCHAR filename[MAX_PATH];
    _TCHAR frameworkroot[MAX_PATH];
    if (!GetEnvironmentVariable(_T("systemroot"),frameworkroot,MAX_PATH))
        return 1;
    _tcscat_s(frameworkroot,_T("\\Microsoft.NET\\Framework\\*"));
    WIN32_FIND_DATA FindFileData;
    HANDLE hFind = FindFirstFile(frameworkroot,&FindFileData);
    if (hFind == INVALID_HANDLE_VALUE)
        return 2;
    do {
        if ((FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
            _tcslen(FindFileData.cAlternateFileName) != 0) {
            _tcsncpy_s(filename,frameworkroot,_tcslen(frameworkroot)-1);
            filename[_tcslen(frameworkroot)] = 0;
            _tcscat_s(filename,FindFileData.cFileName);
            _tcscat_s(filename,_T("\\mscorlib.dll"));
            WORD majorPart,minorPart,buildPart,privatePart;
            if (GetFileVersion(filename,&majorPart,&minorPart,&buildPart,&privatePart )) {
                _tprintf(_T("%d.%d.%d.%d\r\n"),majorPart,minorPart,buildPart,privatePart);
            }
        }
    } while (FindNextFile(hFind,&FindFileData) != 0);
    FindClose(hFind);
    return 0;
}

0

Bem, como Dean disse, você pode olhar o registro e fazer o que ele fez. Para verificar se ele realmente tem o CLR .NET Framework instalado, você deve procurar o MSCorEE.dllarquivo no %SystemRoot%\System32diretório.


0

Provavelmente é uma forma desagradável de descobrir as versões, mas sempre tive a impressão de que todas as versões eram instaladas <root>:\WINDOWS\Microsoft.NET\Framework.

Isso fornece pastas com nomes v2.0.50727que, acredito, fornecem informações detalhadas sobre a versão.


1
E esse pode ser o caminho certo, mas o "e se?" na minha cabeça diz "e se os arquivos estiverem lá, mas o Framework não estiver realmente 'instalado' e algum administrador sem noção pensou que copiar os arquivos era a maneira de fazer isso?"
Tom Kidd

0

Se você quiser encontrar versões anteriores ao .NET 4.5, use o código para um aplicativo de console. Como isso:

using System;
using System.Security.Permissions;
using Microsoft.Win32;

namespace findNetVersion
{
    class Program
    {
        static void Main(string[] args)
        {
            using (RegistryKey ndpKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine,
                     RegistryView.Registry32).OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP\"))
            {
                foreach (string versionKeyName in ndpKey.GetSubKeyNames())
                {
                    if (versionKeyName.StartsWith("v"))
                    {

                        RegistryKey versionKey = ndpKey.OpenSubKey(versionKeyName);
                        string name = (string)versionKey.GetValue("Version", "");
                        string sp = versionKey.GetValue("SP", "").ToString();
                        string install = versionKey.GetValue("Install", "").ToString();
                        if (install == "") //no install info, must be later version
                            Console.WriteLine(versionKeyName + "  " + name);
                        else
                        {
                            if (sp != "" && install == "1")
                            {
                                Console.WriteLine(versionKeyName + "  " + name + "  SP" + sp);
                            }
                        }
                        if (name != "")
                        {
                            continue;
                        }
                        foreach (string subKeyName in versionKey.GetSubKeyNames())
                        {
                            RegistryKey subKey = versionKey.OpenSubKey(subKeyName);
                            name = (string)subKey.GetValue("Version", "");
                            if (name != "")
                                sp = subKey.GetValue("SP", "").ToString();
                                install = subKey.GetValue("Install", "").ToString();
                            if (install == "") //no install info, ust be later
                                Console.WriteLine(versionKeyName + "  " + name);
                            else
                            {
                                if (sp != "" && install == "1")
                                {
                                    Console.WriteLine("  " + subKeyName + "  " + name + "  SP" + sp);
                                }
                                else if (install == "1")
                                {
                                    Console.WriteLine("  " + subKeyName + "  " + name);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

Caso contrário, você pode encontrar o .NET 4.5 ou posterior consultando desta forma:

private static void Get45or451FromRegistry()
{
    using (RegistryKey ndpKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine,
       RegistryView.Registry32).OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full\"))
    {
        int releaseKey = (int)ndpKey.GetValue("Release");
        {
            if (releaseKey == 378389)

                Console.WriteLine("The .NET Framework version 4.5 is installed");

            if (releaseKey == 378758)

                Console.WriteLine("The .NET Framework version 4.5.1  is installed");

        }
    }
}

Em seguida, o resultado do console dirá quais versões estão instaladas e disponíveis para uso com suas implantações. Esse código também é útil porque você os tem como soluções salvas para quando quiser verificá-lo no futuro.


A propósito, você pode querer definir Main como privado desta forma: private static void Main (string [] args) {}
Ronnie Petty

É mais ou menos assim que a Microsoft definiu no MSDN. msdn.microsoft.com/en-us/library/hh925568%28v=vs.110%29.aspx
Ronnie Petty

0

Entrei no Windows Update e olhei o histórico de atualização, sabendo que o patch do servidor é mantido atualizado. Procurei por atualizações do .NET e ele me mostrou exatamente quais versões tinham atualizações, o que me permitiu concluir quais versões estavam instaladas.


Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.