microsoft - ¿Cuál es la manera infalible de saber qué versión(s) de.NET están instaladas en un servidor Windows de producción?

introduccion a contenedores

Question

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

Me encuentro conversando mucho con el grupo de mi compañía, cuyo trabajo es mantener nuestros servidores Windows de producción y desplegar nuestro código en ellos. Por razones legales y de cumplimiento, no tengo visibilidad directa ni control sobre los servidores, por lo que la única forma en que puedo decir qué versión (s) de .NET están instaladas en cualquiera de ellos es a través de las instrucciones que doy a ese grupo.

Hasta ahora, todos los métodos que se me ocurren para decir qué versión (s) están instaladas (compruebe si hay herramientas administrativas que coincidan con 1.1 o 2.0, busque las entradas en la lista "Agregar o quitar programas", compruebe la existencia del directorios en c: / Windows / Microsoft.NET) tienen fallas (he visto al menos una máquina con 2.0 pero ninguna entrada 2.0 en Herramientas administrativas, y ese método no dice nada sobre 3.0+, la lista "Agregar o quitar programas" puede desajustarse de 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 por adelantado (descubrir que "oops, este no tiene todas las versiones y service packs que necesita" en realidad no funciona bien con ventanas de mantenimiento breves) y tengo que hacer la comprobación "por proxy" ya que no puedo acceder directamente a los servidores, ¿cuál es la forma infalible de decir qué versión (es) de .NET están instaladas en un servidor Windows de producción? Preferentemente, una forma intrínseca de hacerlo utilizando lo que instala el framework, ya que será más rápido y no necesitará algún tipo de utilidad para cargarse y también un método que definitivamente fallará si los frameworks no están instalados correctamente, pero aún tienen archivos en su lugar (es decir, , hay un directorio y se incluye gacutil.exe, pero esa versión del framework realmente no está "instalada")

EDITAR: en ausencia de una buena forma intrínseca a prueba de obsoles para hacer esto incorporado en el (los) Marco (s), ¿alguien sabe de un programa bueno, liviano y sin necesidad de instalación que pueda descubrirlo? Puedo imaginar que alguien podría escribir fácilmente uno, pero si uno ya existe, sería aún mejor.

Answer 1

Además, vea la pregunta de Desbordamiento de pila ¿ Cómo detectar qué versiones de .NET Framework y service packs están instaladas? que también menciona:

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

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

Desafortunadamente, no parece funcionar, porque la versión mscorlib.dll en el directorio 2.0 tiene una versión 2.0 y no hay una versión mscorlib.dll en los directorios 3.0 o 3.5 aunque 3.5 SP1 esté instalado ... ¿Por qué? ¿La respuesta oficial de Microsoft estaría tan mal informada?

Answer 2

Bueno, como dijo Dean, puedes mirar el registro y hacer lo que hizo. Para comprobar si realmente tiene CLR .NET Framework instalado, debe buscar el archivo MSCorEE.dll en el %SystemRoot%/System32 .

Answer 3

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

Eso es todo lo que se necesita.

El sitio tiene un script que busca el "UserAgent" de su navegador y se da cuenta de qué versión (si la hay) del .NET Framework que tiene (o no tiene) instalado, y lo muestra automáticamente (luego calcula el tamaño total si elige para descargar el .NET Framework).

Answer 4

Ingresé a Windows Update y miré el historial de actualizaciones, sabiendo que la actualización del servidor se mantiene actualizada. Analicé las actualizaciones de .NET y me mostró exactamente qué versiones tenían actualizaciones, lo que me permitió concluir qué versiones se instalaron.

Answer 5

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.

Answer 6

La implementación de OneTouch hará toda la detección e instalación de requisitos previos. Probablemente sea mejor ir con una solución prefabricada que tratar de hacer la tuya. Intentar rodar el suyo puede provocar problemas porque cualquier cosa que toque puede cambiar con una revisión o un paquete de servicio. Es probable que Microsoft tenga cierta heurística para determinar qué versión se está ejecutando.

Answer 7

La manera de Microsoft es esta:

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 a toda prueba, eso es otra cosa. No me preocuparía una copia de la carpeta de framework. Si alguien hiciera eso, consideraría rota la computadora.

La manera 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 de no instalación, PowerBasic es una excelente herramienta. Crea pequeños exe no necesarios en tiempo de ejecución. Podría automatizar los controles descritos en el artículo anterior de MS KB.

Answer 8

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

Answer 9

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 de 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, targetFramework las versiones deseadas de .NET Framework en la siguiente sección, cambiando los valores de targetFramework como desee:

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

Publique cada objetivo en su servidor, luego vaya a <app deploy URL>/Default . Si su servidor es compatible con la infraestructura de destino, entonces la cadena simple se mostrará desde su controlador trivial. Si no, 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.

Answer 10

Para obtener la versión de dotnet instalada,
Crea 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
}

Answer 11

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

No es infalible, pero lo estoy publicando de todos modos porque me parece gracioso; en eso 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;
}

Answer 12

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

Esto proporciona a las carpetas nombres como v2.0.50727 que, en mi opinión, brindan información detallada sobre la versión.

Answer 13

Puede verificar programáticamente 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/...]

Answer 14

Respuesta encontrada desde here :

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

Answer 15

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

% systemroot% / Microsoft.NET / Framework

Luego busca:

Mscorlib.dll

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

Answer 16

Si desea buscar 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 al consultar 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 indicará 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 desee verificarlos en el futuro.

Answer 17

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

Answer 18

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

Utilice este "programa bueno, liviano y sin instalación requerida"