Il modo migliore per determinare se è installato .NET 3.5

StackOverflow https://stackoverflow.com/questions/16178

Domanda

È necessario determinare a livello di programmazione se è installato .NET 3.5.Pensavo che sarebbe stato facile:

<% Response.Write(Environment.Version.ToString()); %>

Che restituisce "2.0.50727.1434", quindi nessuna fortuna...

Nella mia ricerca ho riscontrato che ci sono alcune chiavi di registro piuttosto oscure che posso esaminare, ma non sono sicuro che questa sia la strada da percorrere.Qualcuno ha qualche suggerimento?

È stato utile?

Soluzione

Potresti provare:

static bool HasNet35()
{
    try
    {
        AppDomain.CurrentDomain.Load(
            "System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
        return true;
    }
    catch
    {
        return false;
    }
}

@Nick:Bella domanda, ci proverò tra un po'.

Kev

Altri suggerimenti

Questo perché tecnicamente .NET 3.5 è un'estensione del framework 2.0.Il modo più rapido consiste nell'includere un assembly da .NET 3.5 e verificare se si interrompe. 

System.Web.Extensions

È un buon assembly incluso solo nella versione 3.5.Inoltre sembra che tu stia utilizzando ASP.NET per eseguire questo controllo, questo ti limita davvero perché non sarai in grado di controllare il file system o il registro in esecuzione nella modalità protetta di ASP.NET.Oppure puoi sempre provare in modo problematico a caricare un assembly dal GAC che dovrebbe essere solo in .NET 3.5, tuttavia potresti riscontrare nuovamente problemi con le autorizzazioni.

Questa potrebbe essere una di quelle volte in cui ti chiedi "Cosa sto cercando di realizzare?" e vedi se ci sono percorsi alternativi.

@Kev, mi piace molto la tua soluzione.Grazie per l'aiuto.

Usando il registro il codice sarebbe simile a questo:

RegistryKey key = Registry
        .LocalMachine
        .OpenSubKey("Software\\Microsoft\\NET Framework Setup\\NDP\\v3.5");
return (key != null);

Sarei curioso di sapere se uno di questi funzionerebbe in un ambiente di media fiducia (anche se sto lavorando in piena fiducia, quindi non importa su cosa sto lavorando attualmente).

@komradekatz, la tua soluzione di seguito da MSDN per comodità per gli altri che stanno esaminando questo problema.Non mi piace questa soluzione perché utilizza l'agente utente per determinare la versione.Questo non è fattibile per ciò di cui ho bisogno (sto scrivendo una libreria di classi che deve sapere se è installato .NET 3.5).Mi chiedo anche quanto affidabile possa rivelarsi questa soluzione.

<%@ Page Language="C#" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<HTML>
  <HEAD>
    <TITLE>Test for the .NET Framework 3.5</TITLE>
    <META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8" />
    <SCRIPT LANGUAGE="JavaScript">
    <!--
    var dotNETRuntimeVersion = "3.5.0.0";

    function window::onload()
    {
      if (HasRuntimeVersion(dotNETRuntimeVersion))
      {
        result.innerText = 
          "This machine has the correct version of the .NET Framework 3.5."
      } 
      else
      {
        result.innerText = 
          "This machine does not have the correct version of the .NET Framework 3.5." +
          " The required version is v" + dotNETRuntimeVersion + ".";
      }
      result.innerText += "\n\nThis machine's userAgent string is: " + 
        navigator.userAgent + ".";
    }

    //
    // Retrieve the version from the user agent string and 
    // compare with the specified version.
    //
    function HasRuntimeVersion(versionToCheck)
    {
      var userAgentString = 
        navigator.userAgent.match(/.NET CLR [0-9.]+/g);

      if (userAgentString != null)
      {
        var i;

        for (i = 0; i < userAgentString.length; ++i)
        {
          if (CompareVersions(GetVersion(versionToCheck), 
            GetVersion(userAgentString[i])) <= 0)
            return true;
        }
      }

      return false;
    }

    //
    // Extract the numeric part of the version string.
    //
    function GetVersion(versionString)
    {
      var numericString = 
        versionString.match(/([0-9]+)\.([0-9]+)\.([0-9]+)/i);
      return numericString.slice(1);
    }

    //
    // Compare the 2 version strings by converting them to numeric format.
    //
    function CompareVersions(version1, version2)
    {
      for (i = 0; i < version1.length; ++i)
      {
        var number1 = new Number(version1[i]);
        var number2 = new Number(version2[i]);

        if (number1 < number2)
          return -1;

        if (number1 > number2)
          return 1;
      }

      return 0;
    }

    -->
    </SCRIPT>
  </HEAD>

  <BODY>
    <div id="result" />
  </BODY>
</HTML>

Sulla mia macchina questo restituisce:

Questa macchina ha la versione corretta di .NET Framework 3.5.

La stringa userAgent di questa macchina è:Mozilla/4.0 (compatibile;MSIE 7.0;WindowsNT6.0;SLCC1;CLR .NET 2.0.50727;.NET CLR 3.0.04506;InfoPath.2;.NET CLR 1.1.4322;.RETE CLR 3.5.21022;Zune 2.5).

Un'altra scoperta interessante è la presenza di assemblee qui:

C:\Programmi iferimento Assembly\Microsoft\Framework\v3.5

Penseresti che Microsoft creerebbe un controllo per la "versione più recente" nel framework.

Se vuoi richiedere l'installazione di una versione specifica di .net e puoi controllare la distribuzione della tua applicazione, dovresti davvero usare Fare clic su una volta.Ti consente di specificare la versione minima richiesta del framework .Net che deve essere installato e controllerà solo durante l'installazione in modo che tutti gli avvii successivi non siano ostacolati da un controllo non necessario.

Inoltre, con ClickOnce ottieni l'aggiornamento gratuitamente.Perché qualcuno non dovrebbe volerlo usare?

Per configurare un'applicazione ClickOnce, è sufficiente fare clic con il pulsante destro del mouse sul progetto in Visual Studio e accedere alle Impostazioni di pubblicazione.Ciò creerà una build speciale della tua applicazione che potrai inserire sul tuo sito web.Quando gli utenti scaricano il programma, il programma di installazione controllerà per te eventuali prerequisiti come .Net.

Un'opzione è rilevare 4.0 utilizzando la stringa della versione:

    Environment.Version.CompareTo(new Version(4, 0));

quindi poiché 2.0 e 2.5 condividono un numero di versione CLR, questi devono essere distinti controllando il registro.Poiché tali versioni sono già state rilasciate, le stringhe da cercare sono note.

Senza alcun caricamento dell'assembly e acquisizione di eccezioni (che è lento), verificare le modifiche dell'API di classe tra 2.0 e 3.5. Stato di classe mono è molto utile per questo.Ad esempio potresti controllare GC.Collect Method (Int32, GCCollectionMode) che è in mscorlib ed è stato aggiunto in 3.5 .

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top