Was ist die narrensichere Methode, um festzustellen, welche .NET-Version (en) auf einem Windows-Produktionsserver installiert sind?

Diese Frage bezieht sich weniger auf die Programmierung als vielmehr auf die Bereitstellung.

Ich unterhalte mich viel mit der Gruppe in meinem Unternehmen, deren Aufgabe es ist, unsere Windows-Produktionsserver zu warten und unseren Code darauf bereitzustellen. Aus rechtlichen und Compliance-Gründen habe ich keine direkte Sichtbarkeit oder Kontrolle über die Server. Daher kann ich nur anhand der Anweisungen, die ich dieser Gruppe gebe, feststellen, welche Version (en) von .NET auf einer dieser Server installiert sind.

Bisher können ich mir alle Methoden vorstellen, um festzustellen, welche Versionen installiert sind (überprüfen Sie, ob die Verwaltung mit 1.1 oder 2.0 übereinstimmt, überprüfen Sie die Einträge in der Liste "Programme hinzufügen / entfernen", und überprüfen Sie, ob die vorhanden sind Verzeichnisse unter c: \ Windows \ Microsoft.NET) sind fehlerhaft (ich habe mindestens einen Computer mit 2.0, aber keinen 2.0-Einträgen unter Verwaltung gesehen - und diese Methode sagt nichts über 3.0+ aus, die Liste "Software" kann nicht mehr mit der Realität synchron sein, und die Existenz der Verzeichnisse bedeutet nicht unbedingt etwas).

Angesichts der Tatsache, dass ich im Allgemeinen wissen muss, dass diese Dinge im Voraus vorhanden sind (wenn ich feststelle, dass "Hoppla, diese Version verfügt nicht über alle Versionen und Service Packs, die Sie benötigen", funktioniert dies bei kurzen Wartungsfenstern nicht wirklich gut), muss ich dies tun Führen Sie die Überprüfung "per Proxy" durch, da ich nicht direkt auf die Server zugreifen kann. Wie kann ich auf kinderleichte Weise feststellen, welche .NET-Version (en) auf einem Windows-Produktionsserver installiert sind? Vorzugsweise eine intrinsische Methode, um das zu verwenden, was das Framework installiert, da es schneller ist und kein Dienstprogramm zum Laden benötigt, und auch eine Methode, die definitiv fehlschlägt, wenn die Frameworks nicht ordnungsgemäß installiert sind, aber noch Dateien vorhanden sind (z gibt es ein Verzeichnis und gacutil.exe ist dort indiziert, aber diese Version des Frameworks ist nicht wirklich "installiert")

BEARBEITEN: Kennt jemand ein gutes, leichtes Programm ohne Installation, das dies herausfinden kann, da es keine gute narrensichere Methode gibt, um dies in die Frameworks zu integrieren? Ich kann mir vorstellen, dass jemand leicht einen schreiben könnte, aber wenn einer bereits existiert, wäre das noch besser.

Sie sollten den IE auf dem Server öffnen, für den Sie nach diesen Informationen suchen, und diese Website aufrufen : http://www.hanselman.com/smallestdotnet/

Das ist alles was es braucht.

Die Site verfügt über ein Skript, das den "UserAgent" Ihres Browsers anzeigt und herausfindet, welche Version (falls vorhanden) von .NET Framework Sie installiert haben (oder nicht installiert haben), und es automatisch anzeigt (und dann die Gesamtgröße berechnet, wenn Sie dies wünschen um das .NET Framework herunterzuladen).

Sie können die Registrierung und einige andere Dinge gemäß diesem Blogeintrag programmgesteuert überprüfen .

Der zu betrachtende Registrierungsschlüssel ist

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

Antwort von hier gefunden :

Überprüfen Sie, welche .NET Framework-Version installiert ist

Öffnen Sie die Eingabeaufforderung und kopieren Sie eine der folgenden Befehlszeilen

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

oder

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

Wie pro CodeTrawler Antwort ist die Lösung der folgenden in ein Explorer - Fenster eingeben:

% systemroot% \ Microsoft.NET \ Framework

Dann suchen Sie nach:

Mscorlib.dll

... und klicken Sie mit der rechten Maustaste auf die Registerkarte Version für jedes Ergebnis.

Der Microsoft-Weg ist folgender:

MSDN: Wie Welche .NET Framework - Versionen bestimmen installiert sind (die Sie auf den folgenden Registrierungsschlüssel richtet: HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\...)

Wenn Sie narrensicher wollen, ist das eine andere Sache. Ich würde mir keine Sorgen um eine Kopie des Framework-Ordners machen. Wenn jemand das tun würde, würde ich den Computer als kaputt betrachten.

Am einfachsten wäre es, ein kleines Programm zu schreiben, das jede Version von .NET und die Bibliotheken verwendet, die Ihnen wichtig sind, und sie auszuführen.

Für eine Methode ohne Installation ist PowerBasic ein hervorragendes Tool. Es werden kleine Exe's erstellt, für die keine Laufzeit erforderlich ist. Es könnte die im obigen MS KB-Artikel beschriebenen Überprüfungen automatisieren.

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

Verwenden Sie dieses "gute, leichte Programm ohne Installation"

Wenn auf dem Computer, den Sie überprüfen möchten, das .NET SDK installiert ist, können Sie eine SDK-Eingabeaufforderung verwenden und das Programm ausführen CLRVer.exe.

Die offizielle Antwort von Microsoft dazu finden Sie im KB-Artikel 318785 .

Die OneTouch-Bereitstellung übernimmt die gesamte Erkennung und Installation der Voraussetzungen. Es ist wahrscheinlich am besten, eine vorgefertigte Lösung zu wählen, als zu versuchen, eine eigene zu rollen. Der Versuch, Ihre eigenen zu rollen, kann zu Problemen führen, da sich alles, was Sie eingeben, mit einem Hotfix oder Service Pack ändern kann. Wahrscheinlich hat Microsoft eine Heuristik, um festzustellen, welche Version ausgeführt wird.

Die offizielle Methode zum Erkennen von .NET 3.0 wird hier beschrieben

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

Fehlerhaft, da der Anrufer über Registrierungszugriffsberechtigungen verfügen muss.

MSDN erwähnt auch eine Technik zum Erkennen von .NET 3.5 durch Überprüfen der User Agent-Zeichenfolge:

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

Ich denke, Microsoft hätte einen besseren Job machen sollen.

Weitere Informationen finden Sie in der Frage zum Stapelüberlauf. Wie erkennt man, welche .NET Framework-Versionen und Service Packs installiert sind? was auch erwähnt:

Eine offizielle Antwort von Microsoft auf diese Frage finden Sie im Knowledge Base-Artikel [So ermitteln Sie, welche Versionen und Service Pack-Levels von Microsoft .NET Framework installiert sind] [2]

Artikel-ID: 318785 - Letzte Überprüfung: 7. November 2008 - Revision: 20.1 So ermitteln Sie, welche Versionen von .NET Framework installiert sind und ob Service Packs angewendet wurden.

Leider scheint es nicht zu funktionieren, weil die mscorlib.dll Version im 2.0-Verzeichnis eine 2.0-Version hat und es mscorlib.dllweder im 3.0- noch im 3.5-Verzeichnis eine Version gibt , obwohl 3.5 SP1 installiert ist ... Warum sollte die offizielle Microsoft-Antwort lauten? so falsch informiert?

So ermitteln Sie die Unterstützung Ihres Servers für .NET Framework 4.5 und neuere Versionen (getestet bis 4.5.2): Wenn Sie keinen Registrierungszugriff auf den Server haben , aber über Veröffentlichungsrechte für Apps auf diesem Server verfügen, erstellen Sie eine MVC 5-App mit einer einfachen Version Controller, wie folgt:

using System.Web.Mvc;

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

Führen Sie dann in Ihrer Web.config die gewünschten .NET Framework-Versionen im folgenden Abschnitt durch und ändern Sie die targetFrameworkWerte wie gewünscht:

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

Veröffentlichen Sie jedes Ziel auf Ihrem Server und navigieren Sie zu <app deploy URL>/Default. Wenn Ihr Server das Zielframework unterstützt, wird die einfache Zeichenfolge von Ihrem trivialen Controller angezeigt. Wenn nicht, erhalten Sie eine Fehlermeldung wie die folgende:

In diesem Fall unterstützt mein Zielserver .NET Framework 4.5.2 noch nicht.

Erstellen Sie eine Konsolen-App, um die installierte Dotnet-Version zu erhalten . Diese Klasse hinzufügen Führen Sie das aus

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
}

Seltsamerweise habe ich einen Code geschrieben, um dies zu tun, als 1.1 herauskam (was war das vor sieben Jahren?) Und ihn ein wenig optimiert, als 2.0 herauskam. Ich habe es mir seit Jahren nicht mehr angesehen, da wir unsere Server nicht mehr verwalten.

Es ist nicht narrensicher, aber ich poste es trotzdem, weil ich es humorvoll finde; , dass es in .NET einfacher ist und noch einfacher 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;
}

Nun, wie Dean sagte, können Sie sich die Registrierung ansehen und das tun, was er getan hat. Um zu überprüfen, ob CLR .NET Framework wirklich installiert ist, sollten Sie nach der MSCorEE.dllDatei im %SystemRoot%\System32Verzeichnis suchen .

Es ist wahrscheinlich eine böse Art, Versionen herauszufinden, aber ich hatte immer den Eindruck, dass alle Versionen installiert wurden <root>:\WINDOWS\Microsoft.NET\Framework .

Dadurch erhalten Ordner Namen, von v2.0.50727denen ich glaube, dass sie detaillierte Versionsinformationen enthalten.

Wenn Sie Versionen vor .NET 4.5 suchen möchten, verwenden Sie Code für eine Konsolenanwendung. So was:

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

Andernfalls können Sie .NET 4.5 oder höher finden, indem Sie Folgendes abfragen:

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

        }
    }
}

Das Konsolenergebnis zeigt Ihnen dann, welche Versionen für Ihre Bereitstellungen installiert und verfügbar sind. Dieser Code ist auch nützlich, da Sie ihn als gespeicherte Lösung haben, wenn Sie ihn in Zukunft überprüfen möchten.

Ich ging zu Windows Update und sah mir den Update-Verlauf an, da ich wusste, dass das Server-Patching auf dem neuesten Stand ist. Ich habe nach .NET-Updates gesucht und es hat mir genau gezeigt, welche Versionen Updates hatten, sodass ich feststellen konnte, welche Versionen installiert wurden.

Ich fand das ziemlich nützlich. Hier ist die Quelle