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

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.

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

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\...]

Resposta encontrada aqui :

Verifique qual versão do .NET Framework está instalada

Abra o prompt de comando e copie e cole uma das linhas de comando abaixo

dir %WINDIR%\Microsoft.Net\Framework\v*

ou

dir %WINDIR%\Microsoft.Net\Framework\v* /O:-N /B

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.

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.

http://www.asoft.be/prod_netver.html

Use este "programa bom, leve e sem necessidade de instalação"

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.

A resposta oficial da Microsoft sobre como fazer isso está no artigo 318785 do KB .

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.

A maneira oficial de detectar .NET 3.0 é descrita aqui

http://msdn.microsoft.com/en-us/library/aa480198.aspx

Falha, porque requer que o chamador tenha permissões de acesso ao registro.

O MSDN também menciona uma técnica para detectar .NET 3.5 verificando a string do Agente do Usuário:

http://msdn.microsoft.com/en-us/library/bb909885.aspx

Acho que a Microsoft deveria ter feito um trabalho melhor do que isso.

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?

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:

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

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
}

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;
}

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.

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.

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.

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.

Eu achei este muito útil. aqui está a fonte