Quel est le moyen infaillible de savoir quelle (s) version (s) de .NET sont installées sur un serveur Windows de production?

Cette question n'est pas tant liée à la programmation qu'au déploiement.

Je me retrouve beaucoup à converser avec le groupe de mon entreprise dont le travail est de maintenir nos serveurs Windows de production et d'y déployer notre code. Pour des raisons juridiques et de conformité, je n'ai pas de visibilité directe ni de contrôle sur les serveurs, donc la seule façon de savoir quelle (s) version (s) de .NET sont installées sur l'une d'entre elles est de suivre les instructions que je donne à ce groupe.

Jusqu'à présent, toutes les méthodes auxquelles je peux penser pour savoir quelle (s) version (s) sont installées (vérifiez les outils d'administration correspondant à 1.1 ou 2.0, vérifiez les entrées dans la liste "Ajout / Suppression de programmes", vérifiez l'existence du répertoires sous c: \ Windows \ Microsoft.NET) sont défectueux (j'ai vu au moins une machine avec 2.0 mais pas d'entrées 2.0 sous Outils d'administration - et cette méthode ne vous dit rien sur 3.0+, la liste "Ajout / Suppression de programmes" peut se désynchroniser avec la réalité, et l'existence des répertoires ne veut pas forcément dire quoi que ce soit).

Étant donné que j'ai généralement besoin de savoir que ces éléments sont en place à l'avance (découvrir que "oups, celui-ci n'a pas toutes les versions et tous les service packs dont vous avez besoin" ne fonctionne pas vraiment bien avec de courtes fenêtres de maintenance) et je dois faire la vérification "par proxy" puisque je ne peux pas accéder directement aux serveurs, quel est le moyen infaillible de savoir quelle (s) version (s) de .NET sont installées sur un serveur Windows de production? De préférence, une manière intrinsèque de le faire en utilisant ce que le framework installe car il sera plus rapide et ne nécessitera pas une sorte d'utilitaire pour être chargé et aussi une méthode qui échouera définitivement si les frameworks ne sont pas correctement installés mais ont toujours des fichiers en place (c.-à-d. , il y a un répertoire et gacutil.exe y est inscrit mais cette version du framework n'est pas vraiment "installée")

EDIT: En l'absence d'un bon moyen intrinsèque infaillible de le faire intégré dans le (s) Framework (s), est-ce que quelqu'un connaît un bon programme léger et sans installation qui peut le découvrir? J'imagine que quelqu'un pourrait facilement en écrire un mais s'il en existe déjà un, ce serait encore mieux.

Vous devez ouvrir IE sur le serveur pour lequel vous recherchez ces informations et vous rendre sur ce site: http://www.hanselman.com/smallestdotnet/

C'est tout ce qu'il faut.

Le site a un script qui ressemble à "UserAgent" de votre navigateur et détermine quelle version (le cas échéant) du .NET Framework vous avez (ou n'avez pas) installé, et l'affiche automatiquement (puis calcule la taille totale si vous avez choisi pour télécharger le .NET Framework).

Vous pouvez vérifier par programme le registre et quelques autres choses selon cette entrée de blog .

La clé de registre à examiner est

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

Réponse trouvée d' ici :

Vérifiez quelle version de .NET Framework est installée

Ouvrez l'invite de commande et copiez-collez l'une des lignes de commande ci-dessous

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

ou

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

Selon la réponse de CodeTrawler , la solution consiste à entrer ce qui suit dans une fenêtre d'explorateur:

% systemroot% \ Microsoft.NET \ Framework

Recherchez ensuite:

Mscorlib.dll

... et cliquez avec le bouton droit de la souris / accédez à l'onglet de version pour chaque résultat.

La méthode Microsoft est la suivante:

MSDN: Comment faire pour déterminer .NET Framework versions sont installées (qui vous dirige vers la clé de Registre suivante: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\...)

Si vous voulez une solution infaillible, c'est autre chose. Je ne m'inquiéterais pas d'une copie x du dossier du framework. Si quelqu'un faisait cela, je considérerais que l'ordinateur est cassé.

Le moyen le plus infaillible serait d'écrire un petit programme qui utilise chaque version de .NET et les bibliothèques qui vous intéressent et de les exécuter.

Pour une méthode sans installation, PowerBasic est un excellent outil. Il crée de petits exe sans exécution requise. Il pourrait automatiser les vérifications décrites dans l'article MS KB ci-dessus.

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

Utilisez ce "bon programme léger, sans installation requise"

Si l'ordinateur que vous souhaitez vérifier a le SDK .NET installé, vous pouvez utiliser une invite de commande SDK et exécuter le programme CLRVer.exe.

La réponse officielle de Microsoft sur la façon de procéder se trouve dans l' article 318785 de la base de connaissances .

Le déploiement OneTouch effectuera toute la détection et l'installation des pré-requis. Il est probablement préférable d'utiliser une solution préfabriquée que d'essayer de créer la vôtre. Essayer de lancer le vôtre peut entraîner des problèmes, car tout élément sur lequel vous entrez peut changer avec un correctif ou un service pack. Microsoft a probablement une heuristique pour déterminer quelle version est en cours d'exécution.

Le moyen officiel de détecter .NET 3.0 est décrit ici

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

Imparfait, car il oblige l'appelant à disposer des autorisations d'accès au registre.

MSDN mentionne également une technique pour détecter .NET 3.5 en vérifiant la chaîne de l'agent utilisateur:

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

Je pense que Microsoft aurait dû faire un meilleur travail que cela.

Consultez également la question sur le débordement de pile Comment détecter les versions et les Service Packs de .NET Framework installés? qui mentionne également:

Il existe une réponse officielle de Microsoft à cette question dans l'article de la base de connaissances [Comment déterminer les versions et les niveaux de service pack de Microsoft .NET Framework installés] [2]

ID de l'article: 318785 - Dernière mise à jour: 7 novembre 2008 - Révision: 20.1 Comment déterminer quelles versions de .NET Framework sont installées et si les service packs ont été appliqués.

Malheureusement, cela ne semble pas fonctionner, car la mscorlib.dllversion du répertoire 2.0 a une version 2.0 et il n'y a aucune mscorlib.dllversion dans les répertoires 3.0 ou 3.5 même si 3.5 SP1 est installé ... Pourquoi la réponse officielle de Microsoft serait si mal informé?

Pour déterminer la prise en charge par votre serveur de .NET Framework 4.5 et versions ultérieures (testées via 4.5.2): Si vous ne disposez pas d'un accès au Registre sur le serveur , mais que vous disposez des droits de publication d'applications sur ce serveur, créez une application MVC 5 avec un élément trivial contrôleur, comme ceci:

using System.Web.Mvc;

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

Ensuite, dans votre Web.config, parcourez les versions de .NET Framework souhaitées dans la section suivante, en modifiant les targetFrameworkvaleurs comme vous le souhaitez:

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

Publiez chaque cible sur votre serveur, puis accédez à <app deploy URL>/Default. Si votre serveur prend en charge le framework cible, la chaîne simple s'affichera à partir de votre contrôleur trivial. Sinon, vous recevrez une erreur comme celle-ci:

Donc, dans ce cas, mon serveur cible ne prend pas encore en charge .NET Framework 4.5.2.

Pour obtenir la version dotnet installée,
créez une application console. Ajoutez cette classe Exécutez cela

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
}

Curieusement, j'ai écrit du code pour faire cela à la sortie de la 1.1 (qu'est-ce que c'était, il y a sept ans?) Et je l'ai légèrement peaufiné lorsque la version 2.0 est sortie. Je ne l'ai pas regardé depuis des années car nous ne gérons plus nos serveurs.

Ce n'est pas infaillible, mais je le poste quand même parce que je le trouve drôle; en ce que c'est plus facile à faire dans .NET et encore plus facile dans 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;
}

Eh bien, comme l'a dit Dean, vous pouvez consulter le registre et faire ce qu'il a fait. Pour vérifier s'il a vraiment installé CLR .NET Framework, vous devez rechercher le MSCorEE.dllfichier dans le %SystemRoot%\System32répertoire.

C'est probablement une mauvaise façon de trouver des versions, mais j'ai toujours eu l'impression que toutes les versions étaient installées <root>:\WINDOWS\Microsoft.NET\Framework.

Cela fournit des dossiers avec des noms tels que ceux v2.0.50727qui, je crois, donnent des informations détaillées sur la version.

Si vous souhaitez rechercher des versions antérieures à .NET 4.5, utilisez le code d'une application console. Comme ça:

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

Sinon, vous pouvez trouver .NET 4.5 ou version ultérieure en interrogeant comme ceci:

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

        }
    }
}

Ensuite, le résultat de la console vous indiquera quelles versions sont installées et disponibles pour une utilisation avec vos déploiements. Ce code est également utile, car vous les avez sous forme de solutions enregistrées à tout moment où vous souhaitez le vérifier à l'avenir.

Je suis entré dans Windows Update et j'ai regardé l'historique des mises à jour, sachant que les correctifs du serveur sont maintenus à jour. J'ai recherché les mises à jour .NET et cela m'a montré exactement quelles versions avaient des mises à jour, ce qui m'a permis de conclure quelles versions étaient installées.

J'ai trouvé celui-ci très utile. voici la source