Qual è il modo infallibile per sapere quali versioni di .NET sono installate su un server Windows di produzione?

Questa domanda non è tanto legata alla programmazione quanto all'implementazione.

Mi trovo a conversare molto con il gruppo della mia azienda il cui compito è mantenere i nostri server Windows di produzione e distribuire il nostro codice su di essi. Per motivi legali e di conformità, non ho visibilità diretta o controllo sui server, quindi l'unico modo in cui posso sapere quale versione (s) di .NET è installata su uno di essi è attraverso le indicazioni che do a quel gruppo.

Finora, tutti i metodi a cui riesco a pensare per sapere quali versioni sono installate (controlla gli strumenti di amministrazione corrispondenti a 1.1 o 2.0, controlla le voci nell'elenco "Installazione applicazioni", controlla l'esistenza del directory in c: \ Windows \ Microsoft.NET) sono difettose (ho visto almeno una macchina con 2.0 ma nessuna voce 2.0 in Strumenti di amministrazione - e quel metodo non dice nulla su 3.0+, l'elenco "Aggiungi / Rimuovi programmi" può non essere sincronizzato con la realtà e l'esistenza delle directory non significa necessariamente nulla).

Dato che generalmente ho bisogno di sapere che queste cose sono a posto in anticipo (scoprire che "oops, questo non ha tutte le versioni e i service pack di cui hai bisogno" non funziona bene con brevi finestre di manutenzione) e devo faccio il controllo "tramite proxy" poiché non riesco ad accedere direttamente ai server, qual è il modo infallibile per sapere quale versione (s) di .NET è installata su un server Windows di produzione? Preferibilmente un modo intrinseco per farlo utilizzando ciò che il framework installa poiché sarà più veloce e non avrà bisogno di qualche tipo di utilità per essere caricato e anche un metodo che fallirà sicuramente se i framework non sono installati correttamente ma hanno ancora file al loro posto (es. , c'è una directory e gacutil.exe è inserito lì ma quella versione del framework non è realmente "installata")

EDIT: In assenza di un buon modo intrinseco infallibile per farlo incorporato nel Framework (s), qualcuno conosce un programma buono, leggero, non richiesto per l'installazione in grado di scoprirlo? Posso immaginare che qualcuno possa scriverne facilmente uno, ma se ne esiste già uno, sarebbe ancora meglio.

Dovresti aprire IE sul server per il quale stai cercando queste informazioni e andare su questo sito: http://www.hanselman.com/smallestdotnet/

È tutto ciò che serve.

Il sito ha uno script che guarda l '"Agente utente" del tuo browser e capisce quale versione (se presente) di .NET Framework hai (o non hai) installato e la visualizza automaticamente (quindi calcola la dimensione totale se hai scelto per scaricare .NET Framework).

Puoi controllare a livello di codice il registro e alcune altre cose come da questo post di blog .

La chiave di registro da esaminare è

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

Risposta trovata da qui :

Verifica quale versione di .NET Framework è installata

Apri il prompt dei comandi e copia e incolla una delle seguenti righe di comando

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

o

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

Secondo la risposta di CodeTrawler , la soluzione è inserire quanto segue in una finestra di esplorazione:

% systemroot% \ Microsoft.NET \ Framework

Quindi cerca:

Mscorlib.dll

... e fai clic con il pulsante destro del mouse / vai alla scheda della versione per ogni risultato.

Il modo in cui Microsoft è questo:

MSDN: Come determinare versioni che si .NET Framework sono installati (che si indirizza alla seguente chiave di registro: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\...)

Se vuoi infallibile è un'altra cosa. Non mi preoccuperei di una xcopy della cartella del framework. Se qualcuno lo facesse, considererei il computer guasto.

Il modo più infallibile sarebbe scrivere un piccolo programma che utilizzi ogni versione di .NET e le librerie che ti interessano ed eseguirle.

Per un metodo senza installazione, PowerBasic è uno strumento eccellente. Crea piccoli file exe senza runtime. Potrebbe automatizzare i controlli descritti nell'articolo di MS KB sopra.

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

Usa questo "programma buono, leggero e non necessario per l'installazione"

Se sul computer che si desidera controllare è installato .NET SDK, è possibile utilizzare un prompt dei comandi SDK ed eseguire il programma CLRVer.exe.

La risposta ufficiale di Microsoft su come eseguire questa operazione è nell'articolo della KB 318785 .

La distribuzione di OneTouch eseguirà tutte le operazioni di rilevamento e installazione dei prerequisiti. Probabilmente è meglio andare con una soluzione prefabbricata piuttosto che provare a lanciarne una tua. Il tentativo di eseguire il rollio può causare problemi perché qualunque cosa si digiti potrebbe cambiare con un hotfix o un service pack. Probabilmente Microsoft ha alcune euristiche per determinare quale versione è in esecuzione.

Il modo ufficiale per rilevare .NET 3.0 è descritto qui

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

Difettoso, perché richiede che il chiamante disponga delle autorizzazioni di accesso al registro.

MSDN menziona anche una tecnica per rilevare .NET 3.5 controllando la stringa dell'agente utente:

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

Penso che Microsoft avrebbe dovuto fare un lavoro migliore di questo.

Inoltre, vedere la domanda sull'overflow dello stack Come rilevare quali versioni di .NET Framework e service pack sono installati? che menziona anche:

C'è una risposta Microsoft ufficiale a questa domanda nell'articolo della knowledge base [Come determinare quali versioni e livelli di service pack di Microsoft .NET Framework sono installati] [2]

Identificativo articolo: 318785 - Ultima modifica: venerdì 7 novembre 2008 - Revisione: 20.1 Come determinare quali versioni di .NET Framework sono installate e se sono stati applicati i service pack.

Sfortunatamente, non sembra funzionare, perché la mscorlib.dllversione nella directory 2.0 ha una versione 2.0 e non esiste alcuna mscorlib.dllversione nelle directory 3.0 o 3.5 anche se è installato 3.5 SP1 ... Perché la risposta ufficiale di Microsoft dovrebbe essere così male informato?

Per determinare il supporto del server per .NET Framework 4.5 e versioni successive (testato fino alla 4.5.2): Se non si dispone dell'accesso al registro sul server , ma si dispone dei diritti di pubblicazione delle app su quel server, creare un'app MVC 5 con un semplice controller, come questo:

using System.Web.Mvc;

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

Quindi nel tuo Web.config, esplora le versioni .NET Framework desiderate nella sezione seguente, modificando i targetFrameworkvalori come desiderato:

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

Pubblica ogni destinazione sul tuo server, quindi vai a <app deploy URL>/Default. Se il tuo server supporta il framework di destinazione, la stringa semplice verrà visualizzata dal tuo controller banale. In caso contrario, riceverai un errore come il seguente:

Quindi, in questo caso, il mio server di destinazione non supporta ancora .NET Framework 4.5.2.

Per ottenere la versione dotnet installata,
crea un'app console. Aggiungi questa classe Esegui quello

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
}

Stranamente, ho scritto del codice per farlo quando è uscito il 1.1 (che cos'era, sette anni fa?) E l'ho modificato un po 'quando è uscito il 2.0. Non lo guardo da anni perché non gestiamo più i nostri server.

Non è infallibile, ma lo pubblico comunque perché lo trovo divertente; in quanto è più facile da fare in .NET e ancora più facile in 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;
}

Bene, come ha detto Dean, puoi guardare il registro e fare quello che ha fatto. Per verificare se ha davvero CLR .NET Framework installato, dovresti cercare il MSCorEE.dllfile nella %SystemRoot%\System32directory.

Probabilmente è un modo brutto per scoprire le versioni, ma ho sempre avuto l'impressione che tutte le versioni fossero state installate <root>:\WINDOWS\Microsoft.NET\Framework .

Questo fornisce cartelle con nomi come quelli v2.0.50727che credo forniscano informazioni dettagliate sulla versione.

Se desideri trovare versioni precedenti a .NET 4.5, utilizza il codice per un'applicazione console. Come questo:

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

Altrimenti puoi trovare .NET 4.5 o versioni successive eseguendo query in questo modo:

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

        }
    }
}

Quindi il risultato della console ti dirà quali versioni sono installate e disponibili per l'uso con le tue distribuzioni. Questo codice è utile, anche perché li hai come soluzioni salvate per ogni volta che vuoi controllarlo in futuro.

Sono entrato in Windows Update e ho guardato la cronologia degli aggiornamenti, sapendo che le patch del server sono mantenute aggiornate. Ho cercato gli aggiornamenti .NET e mi ha mostrato esattamente quali versioni avevano avuto aggiornamenti, il che mi ha permesso di concludere quali versioni erano installate.

Ho trovato questo abbastanza utile. ecco la fonte