¿Cuál es la manera infalible de saber qué versiones de .NET están instaladas en un servidor Windows de producción?

Esta pregunta no está tanto relacionada con la programación como con la implementación.

Me encuentro conversando mucho con el grupo de mi empresa cuyo trabajo es mantener nuestros servidores de producción de Windows e implementar nuestro código en ellos. Por razones legales y de cumplimiento, no tengo visibilidad directa ni control alguno sobre los servidores, por lo que la única forma de saber qué versiones de .NET están instaladas en cualquiera de ellos es a través de las instrucciones que le doy a ese grupo.

Hasta ahora, todos los métodos que se me ocurren para saber qué versión (s) están instaladas (verifique que las Herramientas administrativas coincidan con 1.1 o 2.0, verifique las entradas en la lista "Agregar o quitar programas", verifique la existencia del directorios en c: \ Windows \ Microsoft.NET) tienen fallas (he visto al menos una máquina con 2.0 pero no 2.0 entradas en Herramientas administrativas, y ese método no le dice nada sobre 3.0+, la lista "Agregar o quitar programas" puede perder la sincronización con la realidad, y la existencia de los directorios no significa necesariamente nada).

Dado que generalmente necesito saber que estas cosas están en su lugar de antemano (descubrir que "uy, este no tiene todas las versiones y paquetes de servicio que necesita" realmente no funciona bien con períodos de mantenimiento cortos) y tengo que Hacer la verificación "por proxy" ya que no puedo acceder a los servidores directamente, ¿cuál es la manera infalible de saber qué versión (s) de .NET están instaladas en un servidor Windows de producción? Preferiblemente, alguna forma intrínseca de hacerlo utilizando lo que instala el marco, ya que será más rápido y no necesitará ningún tipo de utilidad para cargarse y también un método que definitivamente fallará si los marcos no están instalados correctamente pero aún tienen archivos en su lugar (es decir, , hay un directorio y gacutil.exe está insertado allí, pero esa versión del marco no está realmente "instalada")

EDITAR: En ausencia de una buena forma intrínseca infalible de hacer esto incorporada en el marco (s), ¿alguien conoce un programa bueno, liviano y que no requiere instalación que pueda descubrir esto? Me imagino que alguien podría escribir uno fácilmente, pero si ya existe, sería aún mejor.

Debe abrir IE en el servidor para el que está buscando esta información e ir a este sitio: http://www.hanselman.com/smallestdotnet/

Eso es todo lo que se necesita.

El sitio tiene una secuencia de comandos que busca el "UserAgent" de su navegador y determina qué versión (si existe) de .NET Framework tiene (o no) instalada, y la muestra automáticamente (luego calcula el tamaño total si lo eligió para descargar .NET Framework).

Puede verificar mediante programación el registro y algunas otras cosas según esta entrada de blog .

La clave de registro para mirar es

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

Respuesta encontrada desde aquí :

Compruebe qué versión de .NET Framework está instalada

Abra el símbolo del sistema y copie y pegue una de las siguientes líneas de comando

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

o

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

Según la respuesta de CodeTrawler , la solución es ingresar lo siguiente en una ventana del explorador:

% systemroot% \ Microsoft.NET \ Framework

Luego busque:

Mscorlib.dll

... y haga clic con el botón derecho / vaya a la pestaña de versión para cada resultado.

La forma de Microsoft es la siguiente:

MSDN: Cómo determinar qué versiones de .NET Framework están instaladas (que lo dirige a la siguiente clave de registro:HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\... )

Si quieres infalible eso es otra cosa. No me preocuparía por una copia de la carpeta del marco. Si alguien hiciera eso, consideraría que la computadora está rota.

La forma más infalible sería escribir un pequeño programa que use cada versión de .NET y las bibliotecas que le interesan y ejecutarlas.

Para un método sin instalación, PowerBasic es una herramienta excelente. Crea pequeños ejecutables que no requieren tiempo de ejecución. Podría automatizar las comprobaciones descritas en el artículo de MS KB anterior.

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

Utilice este "programa bueno, ligero y que no requiere instalación"

Si la máquina que desea verificar tiene .NET SDK instalado, puede usar un símbolo del sistema del SDK y ejecutar el programa CLRVer.exe.

La respuesta oficial de Microsoft sobre cómo hacer esto se encuentra en el artículo 318785 de KB .

La implementación de OneTouch hará toda la detección e instalación de los requisitos previos. Probablemente sea mejor optar por una solución prefabricada que intentar hacer la tuya propia. Tratar de rodar el suyo propio puede generar problemas porque cualquier cosa que ingrese puede cambiar con una revisión o paquete de servicio. Es probable que Microsoft tenga alguna heurística para determinar qué versión se está ejecutando.

La forma oficial de detectar .NET 3.0 se describe aquí

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

Defectuoso, porque requiere que la persona que llama tenga permisos de acceso al registro.

MSDN también menciona una técnica para detectar .NET 3.5 comprobando la cadena del agente de usuario:

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

Creo que Microsoft debería haber hecho un mejor trabajo que este.

Además, consulte la pregunta de Stack Overflow ¿ Cómo detectar qué versiones de .NET Framework y service packs están instalados? que también menciona:

Hay una respuesta oficial de Microsoft a esta pregunta en el artículo de la base de conocimientos [Cómo determinar qué versiones y niveles de paquetes de servicio de Microsoft .NET Framework están instalados] [2]

Id. De artículo: 318785 - Última revisión: 7 de noviembre de 2008 - Versión: 20.1 Cómo determinar qué versiones de .NET Framework están instaladas y si se han aplicado Service Packs.

Desafortunadamente, no parece funcionar, porque la mscorlib.dllversión en el directorio 2.0 tiene una versión 2.0, y no hay ninguna mscorlib.dllversión en los directorios 3.0 o 3.5 a pesar de que 3.5 SP1 está instalado ... ¿Por qué la respuesta oficial de Microsoft sería tan mal informado?

Para determinar el soporte de su servidor para .NET Framework 4.5 y versiones posteriores (probado a través de 4.5.2): Si no tiene acceso al Registro en el servidor , pero tiene derechos de publicación de aplicaciones en ese servidor, cree una aplicación MVC 5 con un trivial controlador, así:

using System.Web.Mvc;

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

Luego, en su Web.config, recorra las versiones de .NET Framework deseadas en la siguiente sección, cambiando los targetFrameworkvalores como desee:

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

Publique cada destino en su servidor, luego busque <app deploy URL>/Default. Si su servidor es compatible con el marco de destino, entonces la cadena simple se mostrará desde su controlador trivial. De lo contrario, recibirá un error como el siguiente:

Entonces, en este caso, mi servidor de destino aún no es compatible con .NET Framework 4.5.2.

Para obtener la versión de dotnet instalada, cree
una aplicación de consola. Agregar esta clase Ejecutar eso

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
}

Curiosamente, escribí un código para hacer esto cuando salió 1.1 (¿qué era eso, hace siete años?) Y lo modifiqué un poco cuando salió 2.0. No lo he mirado en años porque ya no administramos nuestros servidores.

No es infalible, pero lo estoy publicando de todos modos porque lo encuentro gracioso; ya que es más fácil de hacer en .NET y aún más fácil en 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;
}

Bueno, como dijo Dean, puedes mirar el registro y hacer lo que él hizo. Para comprobar si realmente tiene CLR .NET Framework instalado, debe buscar el MSCorEE.dllarchivo en el %SystemRoot%\System32directorio.

Probablemente sea una forma desagradable de averiguar versiones, pero siempre tuve la impresión de que todas las versiones se instalaron <root>:\WINDOWS\Microsoft.NET\Framework.

Esto proporciona carpetas con nombres v2.0.50727que creo que dan información detallada sobre la versión.

Si desea encontrar versiones anteriores a .NET 4.5, use el código para una aplicación de consola. Me gusta esto:

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

De lo contrario, puede encontrar .NET 4.5 o posterior consultando de esta manera:

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");

        }
    }
}

Luego, el resultado de la consola le dirá qué versiones están instaladas y disponibles para usar con sus implementaciones. Este código también es útil porque los tiene como soluciones guardadas para cuando quiera verificarlo en el futuro.

Entré en Windows Update y miré el historial de actualizaciones, sabiendo que el parche del servidor se mantiene actualizado. Busqué actualizaciones de .NET y me mostró exactamente qué versiones habían tenido actualizaciones, lo que me permitió concluir qué versiones estaban instaladas.

Encontré este bastante útil. aquí está la fuente