Jaki jest niezawodny sposób sprawdzenia, które wersje platformy .NET są zainstalowane na produkcyjnym serwerze Windows?

To pytanie nie tyle jest związane z programowaniem, ile z wdrażaniem.

Często rozmawiam z grupą w mojej firmie, której zadaniem jest utrzymywanie naszych produkcyjnych serwerów Windows i wdrażanie na nich naszego kodu. Ze względów prawnych i związanych ze zgodnością nie mam bezpośredniego wglądu w serwery ani żadnej kontroli nad serwerami, więc jedynym sposobem, w jaki mogę sprawdzić, które wersje .NET są zainstalowane na którymkolwiek z nich, są wskazówki, które udzielam tej grupie.

Do tej pory wszystkie metody, które przychodzą mi do głowy, aby stwierdzić, które wersje są zainstalowane (sprawdź, czy narzędzia administracyjne pasują do 1.1 lub 2.0, sprawdź wpisy na liście „Dodaj / usuń programy”, sprawdź, czy istnieją katalogi w c: \ Windows \ Microsoft.NET) są wadliwe (widziałem co najmniej jedną maszynę z wpisami 2.0, ale bez wpisów 2.0 w Narzędziach administracyjnych - i ta metoda nie mówi nic o 3.0+, liście "Dodaj / Usuń programy" może stracić synchronizację z rzeczywistością, a istnienie katalogów niekoniecznie musi cokolwiek oznaczać).

Biorąc pod uwagę, że generalnie muszę wiedzieć, że te rzeczy są na miejscu z wyprzedzeniem (odkrycie, że „Ups, ten nie ma wszystkich wersji i dodatków Service Pack, których potrzebujesz” nie działa dobrze z krótkimi oknami serwisowymi) i muszę sprawdzać „przez proxy”, ponieważ nie mogę uzyskać bezpośredniego dostępu do serwerów. Jaki jest niezawodny sposób sprawdzenia, które wersje .NET są zainstalowane na produkcyjnym serwerze Windows? Najlepiej jest to zrobić za pomocą tego, co instaluje framework, ponieważ będzie to szybsze i nie będzie wymagało załadowania jakiegoś narzędzia, a także metody, która z pewnością zawiedzie, jeśli frameworki nie są poprawnie zainstalowane, ale nadal mają pliki na miejscu (tj. , istnieje katalog, w którym znajduje się plik gacutil.exe, ale ta wersja frameworka nie jest tak naprawdę „zainstalowana”)

EDYCJA: Wobec braku dobrego, niezawodnego, wewnętrznego sposobu zrobienia tego wbudowanego w Framework (y), czy ktoś zna dobry, lekki, niewymagający instalacji program, który może to sprawdzić? Mogę sobie wyobrazić, że ktoś mógłby z łatwością taki napisać, ale jeśli już istnieje, byłoby jeszcze lepiej.

Powinieneś otworzyć IE na serwerze, dla którego szukasz tych informacji i przejść do tej strony: http://www.hanselman.com/smallestdotnet/

To wszystko, czego potrzeba.

Witryna zawiera skrypt, który wygląda jak „UserAgent” przeglądarki i ustala, jaką wersję (jeśli w ogóle) systemu .NET Framework masz (lub nie masz) zainstalowaną, i wyświetla ją automatycznie (a następnie oblicza całkowity rozmiar, jeśli wybierzesz aby pobrać .NET Framework).

Możesz programowo sprawdzić rejestr i kilka innych rzeczy, zgodnie z tym wpisem w blogu .

Klucz rejestru do obejrzenia to

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

Znaleziona odpowiedź stąd :

Sprawdź, która wersja .NET Framework jest zainstalowana

Otwórz wiersz polecenia i skopiuj i wklej jedną z poniższych linii poleceń

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

lub

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

Zgodnie z odpowiedzią CodeTrawler , rozwiązaniem jest wpisanie w oknie eksploratora:

% systemroot% \ Microsoft.NET \ Framework

Następnie wyszukaj:

Mscorlib.dll

... i kliknij prawym przyciskiem myszy / przejdź do karty wersji dla każdego wyniku.

Sposób firmy Microsoft jest następujący:

MSDN: jak ustalić, które wersje .NET Framework są zainstalowane (co kieruje do następującego klucza rejestru:HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\NET Framework Setup\NDP\... )

Jeśli chcesz niezawodności, to inna sprawa. Nie martwiłbym się o kopię zapasową folderu frameworka. Gdyby ktoś to zrobił, uznałbym komputer za zepsuty.

Najbardziej niezawodnym sposobem byłoby napisanie małego programu korzystającego z każdej wersji .NET i bibliotek, na których Ci zależy, i uruchomienie ich.

W przypadku metody bez instalacji PowerBasic jest doskonałym narzędziem. Tworzy małe pliki exe, które nie są wymagane w czasie wykonywania. Może zautomatyzować kontrole opisane w artykule bazy wiedzy MS powyżej.

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

Użyj tego „dobrego, lekkiego, niewymagającego instalacji programu”

Jeśli na komputerze, który chcesz sprawdzić, jest zainstalowany zestaw .NET SDK, możesz użyć wiersza polecenia zestawu SDK i uruchomić program CLRVer.exe.

Oficjalna odpowiedź firmy Microsoft, jak to zrobić, znajduje się w artykule KB 318785 .

Wdrożenie OneTouch wykona wykrywanie i instalację wymagań wstępnych. Prawdopodobnie najlepiej jest skorzystać z gotowego rozwiązania niż próbować rozwinąć własne. Próba zmiany własnej może prowadzić do problemów, ponieważ cokolwiek wprowadzisz, może się zmienić wraz z poprawką lub dodatkiem Service Pack. Prawdopodobnie Microsoft ma pewną heurystykę do określania, która wersja jest uruchomiona.

Oficjalny sposób wykrywania .NET 3.0 jest opisany tutaj

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

Usterka, ponieważ wymaga od dzwoniącego posiadania uprawnień dostępu do rejestru.

MSDN wspomina również o technice wykrywania .NET 3.5, sprawdzając ciąg agenta użytkownika:

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

Myślę, że Microsoft powinien był wykonać lepszą robotę niż to.

Zobacz także pytanie o przepełnienie stosu Jak wykryć, które wersje .NET Framework i dodatki Service Pack są zainstalowane? który również wspomina:

Oficjalna odpowiedź firmy Microsoft na to pytanie znajduje się w artykule bazy wiedzy [Jak ustalić, które wersje i poziomy dodatków Service Pack Microsoft .NET Framework są zainstalowane] [2]

Numer ID artykułu: 318785 - Ostatnia weryfikacja: 7 listopada 2008 r. - Weryfikacja: 20.1 Jak ustalić, które wersje .NET Framework są zainstalowane i czy zostały zastosowane dodatki Service Pack.

Niestety wygląda na to, że nie działa, ponieważ mscorlib.dllwersja w katalogu 2.0 ma wersję 2.0 i nie ma mscorlib.dllwersji ani w katalogach 3.0, ani 3.5, mimo że jest zainstalowany 3.5 SP1 ... Dlaczego oficjalna odpowiedź Microsoft miałaby brzmieć tak źle poinformowany?

Aby określić, czy Twój serwer obsługuje .NET Framework 4.5 i nowsze wersje (testowane do 4.5.2): Jeśli nie masz dostępu do rejestru na serwerze , ale masz prawa do publikowania aplikacji na tym serwerze, utwórz aplikację MVC 5 z prostym kontroler, na przykład ten:

using System.Web.Mvc;

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

Następnie w pliku Web.config przejdź przez żądane wersje platformy .NET Framework w poniższej sekcji, zmieniając odpowiednio targetFrameworkwartości:

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

Opublikuj każdy cel na swoim serwerze, a następnie przejdź do <app deploy URL>/Default. Jeśli twój serwer obsługuje platformę docelową, prosty ciąg zostanie wyświetlony z twojego trywialnego kontrolera. Jeśli nie, pojawi się błąd podobny do następującego:

W tym przypadku mój serwer docelowy nie obsługuje jeszcze .NET Framework 4.5.2.

Aby pobrać zainstalowaną wersję dotnet,
Utwórz aplikację konsoli. Dodaj tę klasę Uruchom to

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
}

O dziwo, napisałem kod, aby to zrobić, kiedy pojawiło się 1.1 (co to było, siedem lat temu?) I trochę go poprawiłem, kiedy pojawiło się 2.0. Nie patrzyłem na to od lat, ponieważ nie zarządzamy już naszymi serwerami.

Nie jest to niezawodny, ale i tak go publikuję, ponieważ uważam to za zabawne; ponieważ jest to łatwiejsze do zrobienia w .NET i jeszcze łatwiejsze w 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;
}

Cóż, jak powiedział Dean, możesz spojrzeć na rejestr i zrobić to, co zrobił. Aby sprawdzić, czy rzeczywiście ma zainstalowane środowisko CLR .NET Framework, należy poszukać MSCorEE.dllpliku w %SystemRoot%\System32katalogu.

To prawdopodobnie nieprzyjemny sposób na znalezienie wersji, ale zawsze miałem wrażenie, że wszystkie wersje zostały zainstalowane <root>:\WINDOWS\Microsoft.NET\Framework.

Zapewnia to foldery o nazwach, v2.0.50727które moim zdaniem zawierają szczegółowe informacje o wersji.

Jeśli chcesz znaleźć wersje wcześniejsze niż .NET 4.5, użyj kodu dla aplikacji konsoli. Lubię to:

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

W przeciwnym razie możesz znaleźć .NET 4.5 lub nowszy, wykonując takie zapytanie:

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

        }
    }
}

Następnie wynik konsoli powie Ci, które wersje są zainstalowane i dostępne do użytku z Twoimi wdrożeniami. Ten kod jest również przydatny, ponieważ masz je jako zapisane rozwiązania w dowolnym momencie, gdy chcesz to sprawdzić w przyszłości.

Wszedłem do Windows Update i spojrzałem na historię aktualizacji, wiedząc, że łatanie serwera jest aktualne. Przeskanowałem w poszukiwaniu aktualizacji .NET i pokazało mi dokładnie, które wersje mają aktualizacje, co pozwoliło mi stwierdzić, które wersje zostały zainstalowane.

Uważam, że ten jest całkiem przydatny. tutaj jest źródło