Il problema è che ho bisogno di sapere se è solo la versione 3.5 SP 1. Environment.Version()ritorna 2.0.50727.3053.
Ho trovato questa soluzione , ma penso che ci vorrà molto più tempo di quanto ne valga la pena, quindi sto cercando una soluzione più semplice. È possibile?
2.0anche se è in esecuzione con 3.5
Risposte:
Qualcosa di simile dovrebbe farlo. Basta prendere il valore dal registro
Per .NET 1-4 :
Frameworkè la versione più recente installata, SPè il service pack per quella versione.
RegistryKey installed_versions = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP");
string[] version_names = installed_versions.GetSubKeyNames();
//version names start with 'v', eg, 'v3.5' which needs to be trimmed off before conversion
double Framework = Convert.ToDouble(version_names[version_names.Length - 1].Remove(0, 1), CultureInfo.InvariantCulture);
int SP = Convert.ToInt32(installed_versions.OpenSubKey(version_names[version_names.Length - 1]).GetValue("SP", 0));
Per .NET 4.5+ (dalla documentazione ufficiale ):
using System;
using Microsoft.Win32;
...
private static void Get45or451FromRegistry()
{
using (RegistryKey ndpKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32).OpenSubKey("SOFTWARE\\Microsoft\\NET Framework Setup\\NDP\\v4\\Full\\")) {
int releaseKey = Convert.ToInt32(ndpKey.GetValue("Release"));
if (true) {
Console.WriteLine("Version: " + CheckFor45DotVersion(releaseKey));
}
}
}
...
// Checking the version using >= will enable forward compatibility,
// however you should always compile your code on newer versions of
// the framework to ensure your app works the same.
private static string CheckFor45DotVersion(int releaseKey)
{
if (releaseKey >= 461808) {
return "4.7.2 or later";
}
if (releaseKey >= 461308) {
return "4.7.1 or later";
}
if (releaseKey >= 460798) {
return "4.7 or later";
}
if (releaseKey >= 394802) {
return "4.6.2 or later";
}
if (releaseKey >= 394254) {
return "4.6.1 or later";
}
if (releaseKey >= 393295) {
return "4.6 or later";
}
if (releaseKey >= 393273) {
return "4.6 RC or later";
}
if ((releaseKey >= 379893)) {
return "4.5.2 or later";
}
if ((releaseKey >= 378675)) {
return "4.5.1 or later";
}
if ((releaseKey >= 378389)) {
return "4.5 or later";
}
// This line should never execute. A non-null release key should mean
// that 4.5 or later is installed.
return "No 4.5 or later version detected";
}
if (true)controllo? Perché non solo la chiamata a Console.WriteLine()?
Non sono sicuro del motivo per cui nessuno ha suggerito di seguire il consiglio ufficiale di Microsoft proprio qui .
Questo è il codice che raccomandano. Certo è brutto, ma funziona.
private static void GetVersionFromRegistry()
{
// Opens the registry key for the .NET Framework entry.
using (RegistryKey ndpKey =
RegistryKey.OpenRemoteBaseKey(RegistryHive.LocalMachine, "").
OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP\"))
{
// As an alternative, if you know the computers you will query are running .NET Framework 4.5
// or later, you can use:
// 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.
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, must 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);
}
}
}
}
}
}
}
// Checking the version using >= will enable forward compatibility,
// however you should always compile your code on newer versions of
// the framework to ensure your app works the same.
private static string CheckFor45DotVersion(int releaseKey)
{
if (releaseKey >= 393295) {
return "4.6 or later";
}
if ((releaseKey >= 379893)) {
return "4.5.2 or later";
}
if ((releaseKey >= 378675)) {
return "4.5.1 or later";
}
if ((releaseKey >= 378389)) {
return "4.5 or later";
}
// This line should never execute. A non-null release key should mean
// that 4.5 or later is installed.
return "No 4.5 or later version detected";
}
private static void Get45or451FromRegistry()
{
using (RegistryKey ndpKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32).OpenSubKey("SOFTWARE\\Microsoft\\NET Framework Setup\\NDP\\v4\\Full\\")) {
if (ndpKey != null && ndpKey.GetValue("Release") != null) {
Console.WriteLine("Version: " + CheckFor45DotVersion((int) ndpKey.GetValue("Release")));
}
else {
Console.WriteLine("Version 4.5 or later is not detected.");
}
}
}
updatesper NET Framework 4.7 e NET Framework 4.7.1 ? Non 4.7 o successivo. Sì 4.7 o 4.7.1.
Un metodo alternativo in cui non è necessario alcun diritto di accesso al registro, è verificare l'esistenza di classi che vengono introdotte in specifici aggiornamenti del framework.
private static bool Is46Installed()
{
// API changes in 4.6: https://github.com/Microsoft/dotnet/blob/master/releases/net46/dotnet46-api-changes.md
return Type.GetType("System.AppContext, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", false) != null;
}
private static bool Is461Installed()
{
// API changes in 4.6.1: https://github.com/Microsoft/dotnet/blob/master/releases/net461/dotnet461-api-changes.md
return Type.GetType("System.Data.SqlClient.SqlColumnEncryptionCngProvider, System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", false) != null;
}
private static bool Is462Installed()
{
// API changes in 4.6.2: https://github.com/Microsoft/dotnet/blob/master/releases/net462/dotnet462-api-changes.md
return Type.GetType("System.Security.Cryptography.AesCng, System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089", false) != null;
}
private static bool Is47Installed()
{
// API changes in 4.7: https://github.com/Microsoft/dotnet/blob/master/releases/net47/dotnet47-api-changes.md
return Type.GetType("System.Web.Caching.CacheInsertOptions, System.Web, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", false) != null;
}
Environment.Version()sta dando la risposta corretta per una domanda diversa. La stessa versione di CLR viene utilizzata in .NET 2.0, 3 e 3.5. Suppongo che potresti controllare il GAC per le librerie che sono state aggiunte in ciascuna di quelle versioni successive.
2.0anche se è in esecuzione con 3.5
In passato era facile, ma Microsoft ha deciso di apportare una modifica sostanziale: prima della versione 4.5, ogni versione di .NET risiedeva nella propria directory sottostante C:\Windows\Microsoft.NET\Framework(sottodirectory v1.0.3705, v1.1.4322, v2.0.50727, v3.0, v3.5e v4.0.30319).
Dalla versione 4.5 questo è stato cambiato: ogni versione di .NET (cioè 4.5.x, 4.6.x, 4.7.x, 4.8.x, ...) viene installata nella stessa sottodirectory v4.0.30319, quindi non sei più in grado di farlo controlla la versione .NET installata esaminando Microsoft.NET\Framework.
Per controllare la versione .NET, Microsoft ha fornito due diversi script di esempio a seconda della versione .NET che viene controllata, ma non mi piace avere due diversi script C # per questo. Quindi ho provato a combinarli in uno, ecco lo script che GetDotNetVersion.csho creato (e aggiornato per il framework 4.7.1):
using System;
using Microsoft.Win32;
public class GetDotNetVersion
{
public static void Main(string[] args)
{
Console.WriteLine((args != null && args.Length > 0)
? "Command line arguments: " + string.Join(",", args)
: "");
string maxDotNetVersion = GetVersionFromRegistry();
if (String.Compare(maxDotNetVersion, "4.5") >= 0)
{
string v45Plus = GetDotNetVersion.Get45PlusFromRegistry();
if (v45Plus != "") maxDotNetVersion = v45Plus;
}
Console.WriteLine("*** Maximum .NET version number found is: " + maxDotNetVersion + "***");
}
private static string Get45PlusFromRegistry()
{
String dotNetVersion = "";
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)
{
dotNetVersion = CheckFor45PlusVersion((int)ndpKey.GetValue("Release"));
Console.WriteLine(".NET Framework Version: " + dotNetVersion);
}
else
{
Console.WriteLine(".NET Framework Version 4.5 or later is not detected.");
}
}
return dotNetVersion;
}
// Checking the version using >= will enable forward compatibility.
private static string CheckFor45PlusVersion(int releaseKey)
{
if (releaseKey >= 528040) return "4.8 or later";
if (releaseKey >= 461808) return "4.7.2";
if (releaseKey >= 461308) return "4.7.1";
if (releaseKey >= 460798) return "4.7";
if (releaseKey >= 394802) return "4.6.2";
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 should mean
// that 4.5 or later is installed.
return "No 4.5 or later version detected";
}
private static string GetVersionFromRegistry()
{
String maxDotNetVersion = "";
// Opens the registry key for the .NET Framework entry.
using (RegistryKey ndpKey = RegistryKey.OpenRemoteBaseKey(RegistryHive.LocalMachine, "")
.OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP\"))
{
// As an alternative, if you know the computers you will query are running .NET Framework 4.5
// or later, you can use:
// 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.
{
Console.WriteLine(versionKeyName + " " + name);
if (String.Compare(maxDotNetVersion, name) < 0) maxDotNetVersion = name;
}
else
{
if (sp != "" && install == "1")
{
Console.WriteLine(versionKeyName + " " + name + " SP" + sp);
if (String.Compare(maxDotNetVersion, name) < 0) maxDotNetVersion = name;
}
}
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, must be later.
Console.WriteLine(versionKeyName + " " + name);
if (String.Compare(maxDotNetVersion, name) < 0) maxDotNetVersion = name;
}
else
{
if (sp != "" && install == "1")
{
Console.WriteLine(" " + subKeyName + " " + name + " SP" + sp);
if (String.Compare(maxDotNetVersion, name) < 0) maxDotNetVersion = name;
}
else if (install == "1")
{
Console.WriteLine(" " + subKeyName + " " + name);
if (String.Compare(maxDotNetVersion, name) < 0) maxDotNetVersion = name;
} // if
} // if
} // for
} // if
} // foreach
} // using
return maxDotNetVersion;
}
} // class
Sulla mia macchina emette:
v2.0.50727 2.0.50727.4927 SP2
v3.0 3.0.30729.4926 SP2
v3.5 3.5.30729.4926 SP1
v4
Client 4.7.03056
Full 4.7.03056
v4.0
Client 4.0.0.0
Versione .NET Framework: 4.7.2 o successiva
*** * Il numero massimo di versioni .NET trovato è: 4.7.2 o successivo ****
L'unica cosa che deve essere mantenuta nel tempo è il numero di build una volta che esce una versione .NET maggiore di 4.7.1 - ciò può essere fatto facilmente modificando la funzione CheckFor45PlusVersion, è necessario conoscere la chiave di rilascio per la nuova versione quindi tu puoi aggiungerlo. Per esempio:
if (releaseKey >= 461308) return "4.7.1 or later";
Questa chiave di rilascio è ancora l'ultima ed è valida per l'aggiornamento Fall Creators di Windows 10. Se stai ancora utilizzando altre versioni (precedenti) di Windows, ce n'è un'altra come da questa documentazione di Microsoft:
.NET Framework 4.7.1 installato su tutte le altre versioni del sistema operativo Windows 461310
Quindi, se hai bisogno anche di quello, dovrai aggiungere
if (releaseKey >= 461310) return "4.7.1 or later";
all'inizio della funzione CheckFor45PlusVersion. Allo stesso modo funziona per le versioni più recenti. Ad esempio, recentemente ho aggiunto l'assegno per 4.8. Di solito puoi trovare quei numeri di build su Microsoft.
Nota: non è necessario installare Visual Studio, nemmeno PowerShell: è possibile utilizzare csc.exeper compilare ed eseguire lo script sopra, che ho descritto qui.
Aggiornamento: la domanda riguarda .NET Framework, per completezza vorrei menzionare come interrogare anche la versione di .NET Core - rispetto a quanto sopra, è facile: apri una shell dei comandi e digita:
dotnet --infoEnter
e elencherà anche il numero di versione di .NET Core, la versione di Windows e le versioni di ciascuna DLL di runtime correlata. Output di esempio:
.NET Core SDK (che riflette qualsiasi global.json):
Versione: 2.1.300
Commit: adab45bf0c
Ambiente di runtime:
Nome sistema
operativo : Windows Versione sistema operativo: 10.0.15063
Piattaforma sistema operativo: Windows
RID: win10-x64
Percorso di base: C: \ Programmi \ dotnet \ sdk \ 2.1.300
Host (utile per il supporto):
Versione: 2.1.0
Commit: caa7b7e2ba
.NET Core SDK installati:
1.1.9 [C: \ Program Files \ dotnet \ sdk]
2.1.102 [C: \ Program Files \ dotnet \ sdk]
...
2.1.300 [C: \ Program Files \ dotnet \ sdk] Runtime
.NET Core installati:
Microsoft.AspNetCore.All 2.1.0 [C: \ Program
Files \ dotnet \ shared \ Microsoft .AspNetCore.All]
...
Microsoft.NETCore.App 2.1.0 [C: \ Program Files \ dotnet \ shared \ Microsoft.NETCore.App]
Per installare ulteriori runtime .NET Core o SDK:
https://aka.ms/dotnet-download
Nota quello
se hai bisogno solo del numero di versione senza tutte le informazioni aggiuntive, puoi usare dotnet --version.
su un PC Windows a 64 bit è possibile installare la versione x86 affiancata alla versione x64 di .NET Core. In questo caso, otterrai solo la versione che viene prima nella variabile d'ambiente PATH. Ciò è particolarmente importante se devi tenerlo aggiornato e vuoi conoscere ogni versione. Per interrogare entrambe le versioni, usa:
C: \ Programmi \ dotnet \ dotnet.exe --version
3.0.100-preview6-012264
C: \ Programmi (x86) \ dotnet \ dotnet.exe --version
3.0.100-preview6-012264
Nell'esempio sopra, entrambi sono uguali, ma se hai dimenticato di aggiornare entrambe le istanze, potresti ottenere risultati diversi! Nota che Program Filesè per la versione a 64 bit ed Program Files (x86)è la versione a 32 bit .
Aggiornamento: se preferisci mantenere i numeri di build in un elenco piuttosto che in una cascata di istruzioni if (come suggerito da Microsoft), puoi utilizzare questo codice per CheckFor45PlusVersion:
private static string CheckFor45PlusVersion(int releaseKey)
{
var release = new Dictionary<int, string>()
{
{ 378389, "4.5" },
{ 378675, "4.5.1" }, { 379893, "4.5.2" },
{ 393295, "4.6" },
{ 394254, "4.6.1" }, { 394802, "4.6.2" },
{ 460798, "4.7" },
{ 461308, "4.7.1" }, { 461808, "4.7.2" },
{ 528040, "4.8 or later" }
};
int result = -1;
foreach(var k in release.OrderBy(k=>k.Key))
{
if (k.Key <= releaseKey) result = k.Key; else break;
};
return (result > 0) ? release[result] : "No 4.5 or later version detected";
}
AFAIK non esiste un metodo integrato nel framework che ti consenta di farlo. Puoi controllare questo post per un suggerimento su come determinare la versione del framework leggendo i valori del registro di Windows.
Questa classe consente alla tua applicazione di lanciare un grazioso messaggio di notifica anziché bloccarsi e masterizzarsi se non riesce a trovare la versione .NET corretta. Tutto quello che devi fare è questo nel tuo codice principale:
[STAThread]
static void Main(string[] args)
{
if (!DotNetUtils.IsCompatible())
return;
. . .
}
Per impostazione predefinita richiede 4.5.2, ma puoi modificarlo a tuo piacimento, la classe (sentiti libero di sostituire MessageBox con Console):
Aggiornato per 4.8:
public class DotNetUtils
{
public enum DotNetRelease
{
NOTFOUND,
NET45,
NET451,
NET452,
NET46,
NET461,
NET462,
NET47,
NET471,
NET472,
NET48,
}
public static bool IsCompatible(DotNetRelease req = DotNetRelease.NET452)
{
DotNetRelease r = GetRelease();
if (r < req)
{
MessageBox.Show(String.Format("This this application requires {0} or greater.", req.ToString()));
return false;
}
return true;
}
public static DotNetRelease GetRelease(int release = default(int))
{
int r = release != default(int) ? release : GetVersion();
if (r >= 528040) return DotNetRelease.NET48;
if (r >= 461808) return DotNetRelease.NET472;
if (r >= 461308) return DotNetRelease.NET471;
if (r >= 460798) return DotNetRelease.NET47;
if (r >= 394802) return DotNetRelease.NET462;
if (r >= 394254) return DotNetRelease.NET461;
if (r >= 393295) return DotNetRelease.NET46;
if (r >= 379893) return DotNetRelease.NET452;
if (r >= 378675) return DotNetRelease.NET451;
if (r >= 378389) return DotNetRelease.NET45;
return DotNetRelease.NOTFOUND;
}
public static int GetVersion()
{
int release = 0;
using (RegistryKey key = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32)
.OpenSubKey("SOFTWARE\\Microsoft\\NET Framework Setup\\NDP\\v4\\Full\\"))
{
release = Convert.ToInt32(key.GetValue("Release"));
}
return release;
}
}
Facilmente estendibile quando aggiungono una nuova versione in seguito. Non mi sono preoccupato di nulla prima della 4.5 ma hai capito.
4.7.1, il numero di revisione è stato preso da docs.microsoft.com/en-us/dotnet/framework/migration-guide/…
IsCompatible(): la compatibilità è probabilmente la ragione più comune per interrogare la versione .Net di tutte.
public class DA
{
public static class VersionNetFramework
{
public static string GetVersion()
{
return Environment.Version.ToString();
}
public static string GetVersionDicription()
{
int Major = Environment.Version.Major;
int Minor = Environment.Version.Minor;
int Build = Environment.Version.Build;
int Revision = Environment.Version.Revision;
//http://dzaebel.net/NetVersionen.htm
//http://stackoverflow.com/questions/12971881/how-to-reliably-detect-the-actual-net-4-5-version-installed
//4.0.30319.42000 = .NET 4.6 on Windows 8.1 64 - bit
if ((Major >=4) && (Minor >=0) && (Build >= 30319) && (Revision >= 42000))
return @".NET 4.6 on Windows 8.1 64 - bit or later";
//4.0.30319.34209 = .NET 4.5.2 on Windows 8.1 64 - bit
if ((Major >= 4) && (Minor >= 0) && (Build >= 30319) && (Revision >= 34209))
return @".NET 4.5.2 on Windows 8.1 64 - bit or later";
//4.0.30319.34209 = .NET 4.5.2 on Windows 7 SP1 64 - bit
if ((Major >= 4) && (Minor >= 0) && (Build >= 30319) && (Revision >= 34209))
return @".NET 4.5.2 on Windows 7 SP1 64 - bit or later";
//4.0.30319.34014 = .NET 4.5.1 on Windows 8.1 64 - bit
if ((Major >= 4) && (Minor >= 0) && (Build >= 30319) && (Revision >= 34014))
return @".NET 4.5.1 on Windows 8.1 64 - bit or later";
//4.0.30319.18444 = .NET 4.5.1 on Windows 7 SP1 64 - bit(with MS14 - 009 security update)
if ((Major >= 4) && (Minor >= 0) && (Build >= 30319) && (Revision >= 18444))
return @".NET 4.5.1 on Windows 7 SP1 64 - bit(with MS14 - 009 security update) or later";
//4.0.30319.18408 = .NET 4.5.1 on Windows 7 SP1 64 - bit
if ((Major >= 4) && (Minor >= 0) && (Build >= 30319) && (Revision >= 18408))
return @".NET 4.5.1 on Windows 7 SP1 64 - bit or later";
//4.0.30319.18063 = .NET 4.5 on Windows 7 SP1 64 - bit(with MS14 - 009 security update)
if ((Major >= 4) && (Minor >= 0) && (Build >= 30319) && (Revision >= 18063))
return @".NET 4.5 on Windows 7 SP1 64 - bit(with MS14 - 009 security update) or later";
//4.0.30319.18052 = .NET 4.5 on Windows 7 SP1 64 - bit
if ((Major >= 4) && (Minor >= 0) && (Build >= 30319) && (Revision >= 18052))
return @".NET 4.5 on Windows 7 SP1 64 - bit or later";
//4.0.30319.18010 = .NET 4.5 on Windows 8
if ((Major >= 4) && (Minor >= 0) && (Build >= 30319) && (Revision >= 18010))
return @".NET 4.5 on Windows 8 or later";
//4.0.30319.17929 = .NET 4.5 RTM
if ((Major >= 4) && (Minor >= 0) && (Build >= 30319) && (Revision >= 17929))
return @".NET 4.5 RTM or later";
//4.0.30319.17626 = .NET 4.5 RC
if ((Major >= 4) && (Minor >= 0) && (Build >= 30319) && (Revision >= 17626))
return @".NET 4.5 RC or later";
//4.0.30319.17020.NET 4.5 Preview, September 2011
if ((Major >= 4) && (Minor >= 0) && (Build >= 30319) && (Revision >= 17020))
return @".NET 4.5 Preview, September 2011 or later";
//4.0.30319.2034 = .NET 4.0 on Windows XP SP3, 7, 7 SP1(with MS14 - 009 LDR security update)
if ((Major >= 4) && (Minor >= 0) && (Build >= 30319) && (Revision >= 2034))
return @".NET 4.0 on Windows XP SP3, 7, 7 SP1(with MS14 - 009 LDR security update) or later";
//4.0.30319.1026 = .NET 4.0 on Windows XP SP3, 7, 7 SP1(with MS14 - 057 GDR security update)
if ((Major >= 4) && (Minor >= 0) && (Build >= 30319) && (Revision >= 1026))
return @".NET 4.0 on Windows XP SP3, 7, 7 SP1(with MS14 - 057 GDR security update) or later";
//4.0.30319.1022 = .NET 4.0 on Windows XP SP3, 7, 7 SP1(with MS14 - 009 GDR security update)
if ((Major >= 4) && (Minor >= 0) && (Build >= 30319) && (Revision >= 1022))
return @".NET 4.0 on Windows XP SP3, 7, 7 SP1(with MS14 - 009 GDR security update) or later";
//4.0.30319.1008 = .NET 4.0 on Windows XP SP3, 7, 7 SP1(with MS13 - 052 GDR security update)
if ((Major >= 4) && (Minor >= 0) && (Build >= 30319) && (Revision >= 1008))
return @".NET 4.0 on Windows XP SP3, 7, 7 SP1(with MS13 - 052 GDR security update) or later";
//4.0.30319.544 = .NET 4.0 on Windows XP SP3, 7, 7 SP1(with MS12 - 035 LDR security update)
if ((Major >= 4) && (Minor >= 0) && (Build >= 30319) && (Revision >= 544))
return @".NET 4.0 on Windows XP SP3, 7, 7 SP1(with MS12 - 035 LDR security update) or later";
//4.0.30319.447 yes built by: RTMLDR, .NET 4.0 Platform Update 1, April 2011
if ((Major >= 4) && (Minor >= 0) && (Build >= 30319) && (Revision >= 447))
return @"built by: RTMLDR, .NET 4.0 Platform Update 1, April 2011 or later";
//4.0.30319.431 yes built by: RTMLDR, .NET 4.0 GDR Update, March 2011 / with VS 2010 SP1 / or.NET 4.0 Update
if ((Major >= 4) && (Minor >= 0) && (Build >= 30319) && (Revision >= 431))
return @"built by: RTMLDR, .NET 4.0 GDR Update, March 2011 / with VS 2010 SP1 / or.NET 4.0 Update or later";
//4.0.30319.296 = .NET 4.0 on Windows XP SP3, 7(with MS12 - 074 GDR security update)
if ((Major >= 4) && (Minor >= 0) && (Build >= 30319) && (Revision >= 296))
return @".NET 4.0 on Windows XP SP3, 7(with MS12 - 074 GDR security update) or later";
//4.0.30319.276 = .NET 4.0 on Windows XP SP3 (4.0.3 Runtime update)
if ((Major >= 4) && (Minor >= 0) && (Build >= 30319) && (Revision >= 276))
return @".NET 4.0 on Windows XP SP3 (4.0.3 Runtime update) or later";
//4.0.30319.269 = .NET 4.0 on Windows XP SP3, 7, 7 SP1(with MS12 - 035 GDR security update)
if ((Major >= 4) && (Minor >= 0) && (Build >= 30319) && (Revision >= 269))
return @".NET 4.0 on Windows XP SP3, 7, 7 SP1(with MS12 - 035 GDR security update) or later";
//4.0.30319.1 yes built by: RTMRel, .NET 4.0 RTM Release, April 2010
if ((Major >= 4) && (Minor >= 0) && (Build >= 30319) && (Revision >= 1))
return @"built by: RTMRel, .NET 4.0 RTM Release, April 2010 or later";
//4.0.30128.1 built by: RC1Rel, .NET 4.0 Release Candidate, Feb 2010
if ((Major >=4) && (Minor >=0) && (Build >= 30128) && (Revision >= 1))
return @"built by: RC1Rel, .NET 4.0 Release Candidate, Feb 2010 or later";
//4.0.21006.1 built by: B2Rel, .NET 4.0 Beta2, Oct 2009
if ((Major >=4) && (Minor >=0) && (Build >= 21006) && (Revision >=1))
return @"built by: B2Rel, .NET 4.0 Beta2, Oct 2009 or later";
//4.0.20506.1 built by: Beta1, .NET 4.0 Beta1, May 2009
if ((Major >=4) && (Minor >=0) && (Build >= 20506) && (Revision >=1))
return @"built by: Beta1, .NET 4.0 Beta1, May 2009 or later";
//4.0.11001.1 built by: CTP2 VPC, .NET 4.0 CTP, October 2008
if ((Major >=4) && (Minor >=0) && (Build >= 11001) && (Revision >=1))
return @"built by: CTP2 VPC, .NET 4.0 CTP, October 2008 or later";
//3.5.30729.5420 yes built by: Win7SP1, .NET 3.5.1 Sicherheits - Update, 12 April 2011
if ((Major >=3) && (Minor >=5) && (Build >= 30729) && (Revision >= 5420))
return @"built by: Win7SP1, .NET 3.5.1 Sicherheits - Update, 12 April 2011 or later";
//3.5.30729.5004 yes built by: NetFXw7 / Windows 7..Rel., Jan 2010 / +Data functions KB976127 .NET 3.5 SP1
if ((Major >=3) && (Minor >=5) && (Build >= 30729) && (Revision >= 5004))
return @"built by: NetFXw7 / Windows 7..Rel., Jan 2010 / +Data functions KB976127 .NET 3.5 SP1 or later";
//3.5.30729.4466 yes built by: NetFXw7 / Windows XP..Rel. , Jan 2010 / +Data functions KB976127 .NET 3.5 SP1
if ((Major >=3) && (Minor >=5) && (Build >= 30729) && (Revision >= 4466))
return @"built by: NetFXw7 / Windows XP..Rel. , Jan 2010 / +Data functions KB976127 .NET 3.5 SP1 or later";
//3.5.30729.4926 yes built by: NetFXw7 / Windows 7 Release, Oct 2009 / .NET 3.5 SP1 + Hotfixes
if ((Major >=3) && (Minor >=5) && (Build >= 30729) && (Revision >= 4926))
return @"built by: NetFXw7 / Windows 7 Release, Oct 2009 / .NET 3.5 SP1 + Hotfixes or later";
//3.5.30729.4918 built by: NetFXw7 / Windows 7 Release Candidate, June 2009
if ((Major >=3) && (Minor >=5) && (Build >= 30729) && (Revision >= 4918))
return @"built by: NetFXw7 / Windows 7 Release Candidate, June 2009 or later";
//3.5.30729.196 yes built by: QFE, .NET 3.5 Family Update Vista / W2008, Dec 2008
if ((Major >= 3) && (Minor >= 5) && (Build >= 30729) && (Revision >=196))
return @"built by: QFE, .NET 3.5 Family Update Vista / W2008, Dec 2008 or later";
//3.5.30729.1 yes built by: SP, .NET 3.5 SP1, Aug 2008
if ((Major >= 3) && (Minor >= 5) && (Build >= 30729) && (Revision >=1))
return @"built by: SP, .NET 3.5 SP1, Aug 2008 or later";
//3.5.30428.1 built by: SP1Beta1, .NET 3.5 SP1 BETA1, May 2008
if ((Major >=3) && (Minor >=5) && (Build >= 30428) && (Revision >=1))
return @"built by: SP1Beta1, .NET 3.5 SP1 BETA1, May 2008 or later";
//3.5.21022.8 yes built by: RTM, Jan 2008
if ((Major >=3) && (Minor >=5) && (Build >= 21022) && (Revision >= 8))
return @"built by: RTM, Jan 2008 or later";
//3.5.20706.1 built by: Beta2, Orcas Beta2, Oct 2007
if ((Major >=3) && (Minor >=5) && (Build >= 20706) && (Revision >= 1))
return @"built by: Beta2, Orcas Beta2, Oct 2007 or later";
//3.5.20526.0 built by: MCritCTP, Orcas Beta1, Mar 2007
if ((Major >=3) && (Minor >=5) && (Build >= 20526) && (Revision >=0))
return @"built by: MCritCTP, Orcas Beta1, Mar 2007 or later";
//3.0.6920.1500 yes built by: QFE, Family Update Vista / W2008, Dez 2008, KB958483
if ((Major >=3) && (Minor >=0) && (Build >= 6920) && (Revision >= 1500))
return @"built by: QFE, Family Update Vista / W2008, Dez 2008, KB958483 or later";
//3.0.4506.4926 yes(NetFXw7.030729 - 4900) / Windows 7 Release, Oct 2009
if ((Major >=3) && (Minor >=0) && (Build >= 4506) && (Revision >= 4926))
return @"(NetFXw7.030729 - 4900) / Windows 7 Release, Oct 2009 or later";
//3.0.4506.4918(NetFXw7.030729 - 4900) / Windows 7 Release Candidate, June 2009
if ((Major >=3) && (Minor >=5) && (Build >= 4506) && (Revision >= 4918))
return @"(NetFXw7.030729 - 4900) / Windows 7 Release Candidate, June 2009 or later";
//3.0.4506.2152 3.0.4506.2152(SP.030729 - 0100) / .NET 4.0 Beta1 / May 2009
if ((Major >= 3) && (Minor >= 5) && (Build >= 4506) && (Revision >= 2152))
return @"3.0.4506.2152(SP.030729 - 0100) / .NET 4.0 Beta1 / May 2009 or later";
//3.0.4506.2123 yes(NetFX.030618 - 0000).NET 3.0 SP2, Aug 2008
if ((Major >= 3) && (Minor >= 5) && (Build >= 4506) && (Revision >= 2123))
return @"s(NetFX.030618 - 0000).NET 3.0 SP2, Aug 2008 or later";
//3.0.4506.2062(SP1Beta1.030428 - 0100), .NET 3.0 SP1 BETA1, May 2008
if ((Major >= 3) && (Minor >= 5) && (Build >= 4506) && (Revision >= 2062))
return @"(SP1Beta1.030428 - 0100), .NET 3.0 SP1 BETA1, May 2008 or later";
//3.0.4506.590(winfxredb2.004506 - 0590), Orcas Beta2, Oct 2007
if ((Major >= 3) && (Minor >= 5) && (Build >= 4506) && (Revision >= 590))
return @"(winfxredb2.004506 - 0590), Orcas Beta2, Oct 2007 or later";
//3.0.4506.577(winfxred.004506 - 0577), Orcas Beta1, Mar 2007
if ((Major >= 3) && (Minor >= 5) && (Build >= 4506) && (Revision >= 577))
return @"(winfxred.004506 - 0577), Orcas Beta1, Mar 2007 or later";
//3.0.4506.30 yes Release (.NET Framework 3.0) Nov 2006
if ((Major >= 3) && (Minor >= 5) && (Build >= 4506) && (Revision >= 30))
return @"Release (.NET Framework 3.0) Nov 2006 or later";
//3.0.4506.25 yes(WAPRTM.004506 - 0026) Vista Ultimate, Jan 2007
if ((Major >= 3) && (Minor >= 5) && (Build >= 4506) && (Revision >= 25))
return @"(WAPRTM.004506 - 0026) Vista Ultimate, Jan 2007 or later";
//2.0.50727.4927 yes(NetFXspW7.050727 - 4900) / Windows 7 Release, Oct 2009
if ((Major >=2) && (Minor >=0) && (Build >= 50727) && (Revision >= 4927))
return @"(NetFXspW7.050727 - 4900) / Windows 7 Release, Oct 2009 or later";
//2.0.50727.4918(NetFXspW7.050727 - 4900) / Windows 7 Release Candidate, June 2009
if ((Major >= 2) && (Minor >= 0) && (Build >= 50727) && (Revision >= 4918))
return @"(NetFXspW7.050727 - 4900) / Windows 7 Release Candidate, June 2009 or later";
//2.0.50727.4200 yes(NetFxQFE.050727 - 4200).NET 2.0 SP2, KB974470, Securityupdate, Oct 2009
if ((Major >= 2) && (Minor >= 0) && (Build >= 50727) && (Revision >= 4200))
return @"(NetFxQFE.050727 - 4200).NET 2.0 SP2, KB974470, Securityupdate, Oct 2009 or later";
//2.0.50727.3603(GDR.050727 - 3600).NET 4.0 Beta 2, Oct 2009
if ((Major >= 2) && (Minor >= 0) && (Build >= 50727) && (Revision >= 3603))
return @"(GDR.050727 - 3600).NET 4.0 Beta 2, Oct 2009 or later";
//2.0.50727.3082 yes(QFE.050727 - 3000), .NET 3.5 Family Update XP / W2003, Dez 2008, KB958481
if ((Major >= 2) && (Minor >= 0) && (Build >= 50727) && (Revision >= 3082))
return @"(QFE.050727 - 3000), .NET 3.5 Family Update XP / W2003, Dez 2008, KB958481 or later";
//2.0.50727.3074 yes(QFE.050727 - 3000), .NET 3.5 Family Update Vista / W2008, Dez 2008, KB958481
if ((Major >= 2) && (Minor >= 0) && (Build >= 50727) && (Revision >= 3074))
return @"(QFE.050727 - 3000), .NET 3.5 Family Update Vista / W2008, Dez 2008, KB958481 or later";
//2.0.50727.3053 yes(netfxsp.050727 - 3000), .NET 2.0 SP2, Aug 2008
if ((Major >= 2) && (Minor >= 0) && (Build >= 50727) && (Revision >= 3053))
return @"yes(netfxsp.050727 - 3000), .NET 2.0 SP2, Aug 2008 or later";
//2.0.50727.3031(netfxsp.050727 - 3000), .NET 2.0 SP2 Beta 1, May 2008
if ((Major >= 2) && (Minor >= 0) && (Build >= 50727) && (Revision >= 3031))
return @"(netfxsp.050727 - 3000), .NET 2.0 SP2 Beta 1, May 2008 or later";
//2.0.50727.1434 yes(REDBITS.050727 - 1400), Windows Server 2008 and Windows Vista SP1, Dez 2007
if ((Major >= 2) && (Minor >= 0) && (Build >= 50727) && (Revision >= 1434))
return @"(REDBITS.050727 - 1400), Windows Server 2008 and Windows Vista SP1, Dez 2007 or later";
//2.0.50727.1433 yes(REDBITS.050727 - 1400), .NET 2.0 SP1 Release, Nov 2007, http://www.microsoft.com/downloads/details.aspx?FamilyID=79bc3b77-e02c-4ad3-aacf-a7633f706ba5
if ((Major >= 2) && (Minor >= 0) && (Build >= 50727) && (Revision >= 1433))
return @"(REDBITS.050727 - 1400), .NET 2.0 SP1 Release, Nov 2007 or later";
//2.0.50727.1378(REDBITSB2.050727 - 1300), Orcas Beta2, Oct 2007
if ((Major >= 2) && (Minor >= 0) && (Build >= 50727) && (Revision >= 1378))
return @"(REDBITSB2.050727 - 1300), Orcas Beta2, Oct 2007 or later";
//2.0.50727.1366(REDBITS.050727 - 1300), Orcas Beta1, Mar 2007
if ((Major >= 2) && (Minor >= 0) && (Build >= 50727) && (Revision >= 1366))
return @"(REDBITS.050727 - 1300), Orcas Beta1, Mar 2007 or later";
//2.0.50727.867 yes(VS Express Edition 2005 SP1), Apr 2007, http://www.microsoft.com/downloads/details.aspx?FamilyId=7B0B0339-613A-46E6-AB4D-080D4D4A8C4E
if ((Major >= 2) && (Minor >= 0) && (Build >= 50727) && (Revision >= 867))
return @"(VS Express Edition 2005 SP1), Apr 2007 or later";
//2.0.50727.832(Fix x86 VC++2005), Apr 2007, http://support.microsoft.com/kb/934586/en-us
if ((Major >= 2) && (Minor >= 0) && (Build >= 50727) && (Revision >= 832))
return @"(Fix x86 VC++2005), Apr 2007 or later";
//2.0.50727.762 yes(VS TeamSuite SP1), http://www.microsoft.com/downloads/details.aspx?FamilyId=BB4A75AB-E2D4-4C96-B39D-37BAF6B5B1DC
if ((Major >= 2) && (Minor >= 0) && (Build >= 50727) && (Revision >= 762))
return @"(VS TeamSuite SP1) or later";
//2.0.50727.312 yes(rtmLHS.050727 - 3100) Vista Ultimate, Jan 2007
if ((Major >= 2) && (Minor >= 0) && (Build >= 50727) && (Revision >= 312))
return @"(rtmLHS.050727 - 3100) Vista Ultimate, Jan 2007 or later";
//2.0.50727.42 yes Release (.NET Framework 2.0) Oct 2005
if ((Major >= 2) && (Minor >= 0) && (Build >= 50727) && (Revision >= 42))
return @"Release (.NET Framework 2.0) Oct 2005 or later";
//2.0.50727.26 Version 2.0(Visual Studio Team System 2005 Release Candidate) Oct 2005
if ((Major >= 2) && (Minor >= 0) && (Build >= 50727) && (Revision >= 26))
return @"Version 2.0(Visual Studio Team System 2005 Release Candidate) Oct 2005 or later";
//2.0.50712 Version 2.0(Visual Studio Team System 2005(Drop3) CTP) July 2005
if ((Major >=2) && (Minor >=0) && (Build >= 50712))
return @"Version 2.0(Visual Studio Team System 2005(Drop3) CTP) July 2005 or later";
//2.0.50215 Version 2.0(WinFX SDK for Indigo / Avalon 2005 CTP) July 2005
if ((Major >=2) && (Minor >=0) && (Build >= 50215))
return @"Version 2.0(WinFX SDK for Indigo / Avalon 2005 CTP) July 2005 or later";
//2.0.50601.0 Version 2.0(Visual Studio.NET 2005 CTP) June 2005
if ((Major >=2) && (Minor >=0) && (Build >= 50601) && (Revision >=0))
return @"Version 2.0(Visual Studio.NET 2005 CTP) June 2005 or later";
//2.0.50215.44 Version 2.0(Visual Studio.NET 2005 Beta 2, Visual Studio Express Beta 2) Apr 2005
if ((Major >=2) && (Minor >=0) && (Build >= 50215) && (Revision >= 44))
return @"Version 2.0(Visual Studio.NET 2005 Beta 2, Visual Studio Express Beta 2) Apr 2005 or later";
//2.0.50110.28 Version 2.0(Visual Studio.NET 2005 CTP, Professional Edition) Feb 2005
if ((Major >=2) && (Minor >=0) && (Build >= 50110) && (Revision >=28))
return @"Version 2.0(Visual Studio.NET 2005 CTP, Professional Edition) Feb 2005 or later";
//2.0.41115.19 Version 2.0(Visual Studio.NET 2005 Beta 1, Team System Refresh) Dec 2004
if ((Major >=2 ) && (Minor >=0 ) && (Build >= 41115) && (Revision >= 19))
return @"Version 2.0(Visual Studio.NET 2005 Beta 1, Team System Refresh) Dec 2004 or later";
//2.0.40903.0 Version 2.0(Whidbey CTP, Visual Studio Express) Oct 2004
if ((Major >=2) && (Minor >=0) && (Build >= 40903) && (Revision >=0))
return @"Version 2.0(Whidbey CTP, Visual Studio Express) Oct 2004 or later";
//2.0.40607.85 Version 2.0(Visual Studio.NET 2005 Beta 1, Team System Refresh) Aug 2004 *
if ((Major >=2) && (Minor >=0) && (Build >= 40607) && (Revision >= 85))
return @"Version 2.0(Visual Studio.NET 2005 Beta 1, Team System Refresh) Aug 2004 * or later";
//2.0.40607.42 Version 2.0(SQL Server Yukon Beta 2) July 2004
if ((Major >=2) && (Minor >=0) && (Build >= 40607) && (Revision >= 42))
return @"Version 2.0(SQL Server Yukon Beta 2) July 2004 or later";
//2.0.40607.16 Version 2.0(Visual Studio.NET 2005 Beta 1, TechEd Europe 2004) June 2004
if ((Major >=2) && (Minor >=0) && (Build >= 40607) && (Revision >= 16))
return @"Version 2.0(Visual Studio.NET 2005 Beta 1, TechEd Europe 2004) June 2004 or later";
//2.0.40301.9 Version 2.0(Whidbey CTP, WinHEC 2004) March 2004 *
if ((Major >=0) && (Minor >=0) && (Build >= 40301) && (Revision >=9))
return @"Version 2.0(Whidbey CTP, WinHEC 2004) March 2004 * or later";
//1.2.30703.27 Version 1.2(Whidbey Alpha, PDC 2004) Nov 2003 *
if ((Major >=1) && (Minor >=2) && (Build >= 30703) && (Revision >= 27))
return @"Version 1.2(Whidbey Alpha, PDC 2004) Nov 2003 * or later";
//1.2.21213.1 Version 1.2(Whidbey pre - Alpha build) *
if ((Major >=1) && (Minor >=2) && (Build >= 21213) && (Revision >=1))
return @"Version 1.2(Whidbey pre - Alpha build) * or later";
//1.1.4322.2443 yes Version 1.1 Servicepack 1, KB953297, Oct 2009
if ((Major >=1) && (Minor >=1) && (Build >= 4322) && (Revision >=2443))
return @"Version 1.1 Servicepack 1, KB953297, Oct 2009 or later";
//1.1.4322.2407 yes Version 1.1 RTM
if ((Major >=1) && (Minor >=1) && (Build >= 4322) && (Revision >= 2407))
return @"Version 1.1 RTM or later";
//1.1.4322.2407 Version 1.1 Orcas Beta2, Oct 2007
if ((Major >=1) && (Minor >=1) && (Build >= 4322) && (Revision >= 2407))
return @"Version 1.1 Orcas Beta2, Oct 2007 or later";
//1.1.4322.2379 Version 1.1 Orcas Beta1, Mar 2007
if ((Major >=1) && (Minor >=1) && (Build >= 4322) && (Revision >= 2379))
return @"Version 1.1 Orcas Beta1, Mar 2007 or later";
//1.1.4322.2032 yes Version 1.1 SP1 Aug 2004
if ((Major >=1) && (Minor >=1) && (Build >= 4322) && (Revision >= 2032))
return @"Version 1.1 SP1 Aug 2004 or later";
//1.1.4322.573 yes Version 1.1 RTM(Visual Studio.NET 2003 / Windows Server 2003) Feb 2003 *
if ((Major >=1) && (Minor >=1) && (Build >= 4322) && (Revision >= 573))
return @"Version 1.1 RTM(Visual Studio.NET 2003 / Windows Server 2003) Feb 2003 * or later";
//1.1.4322.510 Version 1.1 Final Beta Oct 2002 *
if ((Major >=1) && (Minor >=1) && (Build >= 4322) && (Revision >= 510))
return @"Version 1.1 Final Beta Oct 2002 * or later";
//1.0.3705.6018 yes Version 1.0 SP3 Aug 2004
if ((Major >=1) && (Minor >=0) && (Build >= 3705) && (Revision >= 6018))
return @"Version 1.0 SP3 Aug 2004 or later";
//1.0.3705.288 yes Version 1.0 SP2 Aug 2002 *
if ((Major >=1) && (Minor >=0) && (Build >= 3705) && (Revision >= 288))
return @"Version 1.0 SP2 Aug 2002 * or later";
//1.0.3705.209 yes Version 1.0 SP1 Mar 2002 *
if ((Major >=1) && (Minor >=0) && (Build >= 3705) && (Revision >=209))
return @"Version 1.0 SP1 Mar 2002 * or later";
//1.0.3705.0 yes Version 1.0 RTM(Visual Studio.NET 2002) Feb 2002 *
if ((Major >=1) && (Minor >=0) && (Build >= 3705) && (Revision >=0))
return @"Version 1.0 RTM(Visual Studio.NET 2002) Feb 2002 * or later";
//1.0.3512.0 Version 1.0 Pre - release RC3(Visual Studio.NET 2002 RC3)
if ((Major >=1) && (Minor >=0) && (Build >= 3512) && (Revision >=0))
return @"Version 1.0 Pre - release RC3(Visual Studio.NET 2002 RC3) or later";
//1.0.2914.16 Version 1.0 Public Beta 2 Jun 2001 *
if ((Major >=1) && (Minor >=0) && (Build >= 2914) && (Revision >= 16))
return @"Version 1.0 Public Beta 2 Jun 2001 * or later";
//1.0.2204.21 Version 1.0 Public Beta 1 Nov 2000 *
if ((Major >=1) && (Minor >=0) && (Build >= 2204) && (Revision >=21))
return @"Version 1.0 Public Beta 1 Nov 2000 * or later";
return @"Unknown .NET version";
}
}
}
Ho avuto una situazione in cui la mia libreria di classi .NET 4.0 potrebbe essere chiamata da un assembly di versione .NET 4.0 o successiva.
Una chiamata a un metodo specifico funzionerebbe solo se eseguita da un assembly 4.5+.
Per decidere se chiamare o meno il metodo avevo bisogno di determinare la versione corrente del framework in esecuzione e questa è una soluzione abbastanza buona per questo
var frameworkName = new System.Runtime.Versioning.FrameworkName(
AppDomain.CurrentDomain.SetupInformation.TargetFrameworkName
);
if (frameworkName.Version >= new Version(4, 5))
{
// run code
}
Grazie per questo post che è stato abbastanza utile. Ho dovuto modificarlo un po 'per controllare il framework 2.0 perché la chiave di registro non può essere convertita immediatamente in una doppia. Ecco il codice:
string[] version_names = rk.GetSubKeyNames();
//version names start with 'v', eg, 'v3.5'
//we also need to take care of strings like v2.0.50727...
string sCurrent = version_names[version_names.Length - 1].Remove(0, 1);
if (sCurrent.LastIndexOf(".") > 1)
{
string[] sSplit = sCurrent.Split('.');
sCurrent = sSplit[0] + "." + sSplit[1] + sSplit[2];
}
double dCurrent = Convert.ToDouble(sCurrent, System.Globalization.CultureInfo.InvariantCulture);
double dExpected = Convert.ToDouble(sExpectedVersion);
if (dCurrent >= dExpected)
public class DA {
public static class VersionNetFramework {
public static string Get45or451FromRegistry()
{//https://msdn.microsoft.com/en-us/library/hh925568(v=vs.110).aspx
using (RegistryKey ndpKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32).OpenSubKey("SOFTWARE\\Microsoft\\NET Framework Setup\\NDP\\v4\\Full\\"))
{
int releaseKey = Convert.ToInt32(ndpKey.GetValue("Release"));
if (true)
{
return (@"Version: " + CheckFor45DotVersion(releaseKey));
}
}
}
// Checking the version using >= will enable forward compatibility,
// however you should always compile your code on newer versions of
// the framework to ensure your app works the same.
private static string CheckFor45DotVersion(int releaseKey)
{//https://msdn.microsoft.com/en-us/library/hh925568(v=vs.110).aspx
if (releaseKey >= 394271)
return "4.6.1 installed on all other Windows OS versions or later";
if (releaseKey >= 394254)
return "4.6.1 installed on Windows 10 or later";
if (releaseKey >= 393297)
return "4.6 installed on all other Windows OS versions or later";
if (releaseKey >= 393295)
return "4.6 installed with Windows 10 or later";
if (releaseKey >= 379893)
return "4.5.2 or later";
if (releaseKey >= 378758)
return "4.5.1 installed on Windows 8, Windows 7 SP1, or Windows Vista SP2 or later";
if (releaseKey >= 378675)
return "4.5.1 installed with Windows 8.1 or later";
if (releaseKey >= 378389)
return "4.5 or later";
return "No 4.5 or later version detected";
}
public static string GetVersionFromRegistry()
{//https://msdn.microsoft.com/en-us/library/hh925568(v=vs.110).aspx
string res = @"";
// Opens the registry key for the .NET Framework entry.
using (RegistryKey ndpKey =
RegistryKey.OpenRemoteBaseKey(RegistryHive.LocalMachine, "").
OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP\"))
{
// As an alternative, if you know the computers you will query are running .NET Framework 4.5
// or later, you can use:
// 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.
res += (versionKeyName + " " + name) + Environment.NewLine;
else
{
if (sp != "" && install == "1")
{
res += (versionKeyName + " " + name + " SP" + sp) + Environment.NewLine;
}
}
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, must be later.
res += (versionKeyName + " " + name) + Environment.NewLine;
else
{
if (sp != "" && install == "1")
{
res += (" " + subKeyName + " " + name + " SP" + sp) + Environment.NewLine;
}
else if (install == "1")
{
res += (" " + subKeyName + " " + name) + Environment.NewLine;
}
}
}
}
}
}
return res;
}
public static string GetUpdateHistory()
{//https://msdn.microsoft.com/en-us/library/hh925567(v=vs.110).aspx
string res=@"";
using (RegistryKey baseKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32).OpenSubKey(@"SOFTWARE\Microsoft\Updates"))
{
foreach (string baseKeyName in baseKey.GetSubKeyNames())
{
if (baseKeyName.Contains(".NET Framework") || baseKeyName.StartsWith("KB") || baseKeyName.Contains(".NETFramework"))
{
using (RegistryKey updateKey = baseKey.OpenSubKey(baseKeyName))
{
string name = (string)updateKey.GetValue("PackageName", "");
res += baseKeyName + " " + name + Environment.NewLine;
foreach (string kbKeyName in updateKey.GetSubKeyNames())
{
using (RegistryKey kbKey = updateKey.OpenSubKey(kbKeyName))
{
name = (string)kbKey.GetValue("PackageName", "");
res += (" " + kbKeyName + " " + name) + Environment.NewLine;
if (kbKey.SubKeyCount > 0)
{
foreach (string sbKeyName in kbKey.GetSubKeyNames())
{
using (RegistryKey sbSubKey = kbKey.OpenSubKey(sbKeyName))
{
name = (string)sbSubKey.GetValue("PackageName", "");
if (name == "")
name = (string)sbSubKey.GetValue("Description", "");
res += (" " + sbKeyName + " " + name) + Environment.NewLine;
}
}
}
}
}
}
}
}
}
return res;
}
}
utilizzando la classe DA.VersionNetFramework
private void Form1_Shown(object sender, EventArgs e)
{
//
// Current OS Information
//
richTextBox1.Text = @"Current OS Information:";
richTextBox1.AppendText(Environment.NewLine +
"Machine Name: " + Environment.MachineName);
richTextBox1.AppendText(Environment.NewLine +
"Platform: " + Environment.OSVersion.Platform.ToString());
richTextBox1.AppendText(Environment.NewLine +
Environment.OSVersion);
//
// .NET Framework Environment Information
//
richTextBox1.AppendText(Environment.NewLine + Environment.NewLine +
".NET Framework Environment Information:");
richTextBox1.AppendText(Environment.NewLine +
"Environment.Version " + Environment.Version);
richTextBox1.AppendText(Environment.NewLine +
DA.VersionNetFramework.GetVersionDicription());
//
// .NET Framework Information From Registry
//
richTextBox1.AppendText(Environment.NewLine + Environment.NewLine +
".NET Framework Information From Registry:");
richTextBox1.AppendText(Environment.NewLine +
DA.VersionNetFramework.GetVersionFromRegistry());
//
// .NET Framework 4.5 or later Information From Registry
//
richTextBox1.AppendText(Environment.NewLine +
".NET Framework 4.5 or later Information From Registry:");
richTextBox1.AppendText(Environment.NewLine +
DA.VersionNetFramework.Get45or451FromRegistry());
//
// Update History
//
richTextBox1.AppendText(Environment.NewLine + Environment.NewLine +
"Update History");
richTextBox1.AppendText(Environment.NewLine +
DA.VersionNetFramework.GetUpdateHistory());
//
// Setting Cursor to first character of textbox
//
if (!richTextBox1.Text.Equals(""))
{
richTextBox1.SelectionStart = 1;
}
}
Risultato:
Informazioni sul sistema operativo corrente: Nome computer: D1 Piattaforma: Win32NT Microsoft Windows NT 6.2.9200.0
Informazioni sull'ambiente .NET Framework: Environment.Version 4.0.30319.42000 .NET 4.6 su Windows 8.1 a 64 bit o successivo
Informazioni .NET Framework dal registro: v2.0.50727 2.0.50727.4927 SP2 v3.0 3.0.30729.4926 SP2 v3.5 3.5.30729.4926 SP1
v4
Client 4.6.00079 Completo 4.6.00079
Client v4.0 4.0.0.0
.NET Framework 4.5 o successivo Informazioni dal registro: Versione: 4.6 installato con Windows 10 o successivo
Cronologia aggiornamenti Microsoft .NET Framework 4 Profilo client
KB2468871
KB2468871v2
KB2478063
KB2533523
KB2544514
KB2600211
KB2600217
Microsoft .NET Framework 4 esteso
KB2468871
KB2468871v2
KB2478063
KB2533523
KB2544514
KB2600211
KB2600217
Microsoft .NET Framework 4 Multi-Targeting250 Pacchetto
KB37
Ho cambiato la classe di Matt in modo che possa essere riutilizzato in qualsiasi progetto senza stampare tutti i suoi controlli su Console e restituendo una semplice stringa con la versione massima corretta installata.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Win32;
namespace MyNamespace
{
public class DotNetVersion
{
protected bool printVerification;
public DotNetVersion(){
this.printVerification=false;
}
public DotNetVersion(bool printVerification){
this.printVerification=printVerification;
}
public string getDotNetVersion(){
string maxDotNetVersion = getVersionFromRegistry();
if(String.Compare(maxDotNetVersion, "4.5") >= 0){
string v45Plus = get45PlusFromRegistry();
if(!string.IsNullOrWhiteSpace(v45Plus)) maxDotNetVersion = v45Plus;
}
log("*** Maximum .NET version number found is: " + maxDotNetVersion + "***");
return maxDotNetVersion;
}
protected string get45PlusFromRegistry(){
String dotNetVersion = "";
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){
dotNetVersion = checkFor45PlusVersion((int)ndpKey.GetValue("Release"));
log(".NET Framework Version: " + dotNetVersion);
}else{
log(".NET Framework Version 4.5 or later is not detected.");
}
}
return dotNetVersion;
}
// Checking the version using >= will enable forward compatibility.
protected string checkFor45PlusVersion(int releaseKey){
if(releaseKey >= 461308) return "4.7.1 or later";
if(releaseKey >= 460798) return "4.7";
if(releaseKey >= 394802) return "4.6.2";
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 should mean
// that 4.5 or later is installed.
log("No 4.5 or later version detected");
return "";
}
protected string getVersionFromRegistry(){
String maxDotNetVersion = "";
// Opens the registry key for the .NET Framework entry.
using(RegistryKey ndpKey = RegistryKey.OpenRemoteBaseKey(RegistryHive.LocalMachine, "")
.OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP\")){
// As an alternative, if you know the computers you will query are running .NET Framework 4.5
// or later, you can use:
// using(RegistryKey ndpKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine,
// RegistryView.Registry32).OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP\"))
string[] subKeyNnames = ndpKey.GetSubKeyNames();
foreach(string versionKeyName in subKeyNnames){
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(string.IsNullOrWhiteSpace(install)){ //no install info, must be later.
log(versionKeyName + " " + name);
if(String.Compare(maxDotNetVersion, name) < 0) maxDotNetVersion = name;
}else{
if(!string.IsNullOrWhiteSpace(sp) && "1".Equals(install)){
log(versionKeyName + " " + name + " SP" + sp);
if(String.Compare(maxDotNetVersion, name) < 0) maxDotNetVersion = name;
}
}
if(!string.IsNullOrWhiteSpace(name)){
continue;
}
string[] subKeyNames = versionKey.GetSubKeyNames();
foreach(string subKeyName in subKeyNames){
RegistryKey subKey = versionKey.OpenSubKey(subKeyName);
name =(string)subKey.GetValue("Version", "");
if(!string.IsNullOrWhiteSpace(name)){
sp = subKey.GetValue("SP", "").ToString();
}
install = subKey.GetValue("Install", "").ToString();
if(string.IsNullOrWhiteSpace(install)){
//no install info, must be later.
log(versionKeyName + " " + name);
if(String.Compare(maxDotNetVersion, name) < 0) maxDotNetVersion = name;
}else{
if(!string.IsNullOrWhiteSpace(sp) && "1".Equals(install)){
log(" " + subKeyName + " " + name + " SP" + sp);
if(String.Compare(maxDotNetVersion, name) < 0) maxDotNetVersion = name;
}
else if("1".Equals(install)){
log(" " + subKeyName + " " + name);
if(String.Compare(maxDotNetVersion, name) < 0) maxDotNetVersion = name;
} // if
} // if
} // for
} // if
} // foreach
} // using
return maxDotNetVersion;
}
protected void log(string message){
if(printVerification) Console.WriteLine(message);
}
} // class
}
Ho provato a combinare tutte le risposte in un unico insieme.
Utilizzando:
NetFrameworkUtilities.GetVersion()restituirà la versione attualmente disponibile di .NET Framework in questo momento o null se non è presente.
Questo esempio funziona nelle versioni di .NET Framework 3.5+. Non richiede diritti di amministratore.
Voglio notare che puoi controllare la versione usando gli operatori <e> in questo modo:
var version = NetFrameworkUtilities.GetVersion();
if (version != null && version < new Version(4, 5))
{
MessageBox.Show("Your .NET Framework version is less than 4.5");
}
Codice:
using System;
using System.Linq;
using Microsoft.Win32;
namespace Utilities
{
public static class NetFrameworkUtilities
{
public static Version GetVersion() => GetVersionHigher4() ?? GetVersionLowerOr4();
private static Version GetVersionLowerOr4()
{
using (var key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP"))
{
var names = key?.GetSubKeyNames();
//version names start with 'v', eg, 'v3.5' which needs to be trimmed off before conversion
var text = names?.LastOrDefault()?.Remove(0, 1);
if (string.IsNullOrEmpty(text))
{
return null;
}
return text.Contains('.')
? new Version(text)
: new Version(Convert.ToInt32(text), 0);
}
}
private static Version GetVersionHigher4()
{
using (var key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full"))
{
var value = key?.GetValue("Release");
if (value == null)
{
return null;
}
// Checking the version using >= will enable forward compatibility,
// however you should always compile your code on newer versions of
// the framework to ensure your app works the same.
var releaseKey = Convert.ToInt32(value);
if (releaseKey >= 461308) return new Version(4, 7, 1);
if (releaseKey >= 460798) return new Version(4, 7);
if (releaseKey >= 394747) return new Version(4, 6, 2);
if (releaseKey >= 394254) return new Version(4, 6, 1);
if (releaseKey >= 381029) return new Version(4, 6);
if (releaseKey >= 379893) return new Version(4, 5, 2);
if (releaseKey >= 378675) return new Version(4, 5, 1);
if (releaseKey >= 378389) return new Version(4, 5);
// This line should never execute. A non-null release key should mean
// that 4.5 or later is installed.
return new Version(4, 5);
}
}
}
}
Aggiornamento con .NET 4.6.2. Controlla il valore di rilascio nello stesso registro delle risposte precedenti:
RegistryKey registry_key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full");
if (registry_key == null)
return false;
var val = registry_key.GetValue("Release", 0);
UInt32 Release = Convert.ToUInt32(val);
if (Release >= 394806) // 4.6.2 installed on all other Windows (different than Windows 10)
return true;
if (Release >= 394802) // 4.6.2 installed on Windows 10 or later
return true;
updatesper NET Framework 4.7 e NET Framework 4.7.1 ?
Poco grande, ma sembra che sia aggiornato alle stranezze di Microsoft:
public static class Versions
{
static Version
_NET;
static SortedList<String,Version>
_NETInstalled;
#if NET40
#else
public static bool VersionTry(String S, out Version V)
{
try
{
V=new Version(S);
return true;
}
catch
{
V=null;
return false;
}
}
#endif
const string _NetFrameWorkKey = "SOFTWARE\\Microsoft\\NET Framework Setup\\NDP";
static void FillNetInstalled()
{
if (_NETInstalled == null)
{
_NETInstalled = new SortedList<String, Version>(StringComparer.InvariantCultureIgnoreCase);
RegistryKey
frmks = Registry.LocalMachine.OpenSubKey(_NetFrameWorkKey);
string[]
names = frmks.GetSubKeyNames();
foreach (string name in names)
{
if (name.StartsWith("v", StringComparison.InvariantCultureIgnoreCase) && name.Length > 1)
{
string
f, vs;
Version
v;
vs = name.Substring(1);
if (vs.IndexOf('.') < 0)
vs += ".0";
#if NET40
if (Version.TryParse(vs, out v))
#else
if (VersionTry(vs, out v))
#endif
{
f = String.Format("{0}.{1}", v.Major, v.Minor);
#if NET40
if (Version.TryParse((string)frmks.OpenSubKey(name).GetValue("Version"), out v))
#else
if (VersionTry((string)frmks.OpenSubKey(name).GetValue("Version"), out v))
#endif
{
if (!_NETInstalled.ContainsKey(f) || v.CompareTo(_NETInstalled[f]) > 0)
_NETInstalled[f] = v;
}
else
{ // parse variants
Version
best = null;
if (_NETInstalled.ContainsKey(f))
best = _NETInstalled[f];
string[]
varieties = frmks.OpenSubKey(name).GetSubKeyNames();
foreach (string variety in varieties)
#if NET40
if (Version.TryParse((string)frmks.OpenSubKey(name + '\\' + variety).GetValue("Version"), out v))
#else
if (VersionTry((string)frmks.OpenSubKey(name + '\\' + variety).GetValue("Version"), out v))
#endif
{
if (best == null || v.CompareTo(best) > 0)
{
_NETInstalled[f] = v;
best = v;
}
vs = f + '.' + variety;
if (!_NETInstalled.ContainsKey(vs) || v.CompareTo(_NETInstalled[vs]) > 0)
_NETInstalled[vs] = v;
}
}
}
}
}
}
} // static void FillNetInstalled()
public static Version NETInstalled
{
get
{
FillNetInstalled();
return _NETInstalled[_NETInstalled.Keys[_NETInstalled.Count-1]];
}
} // NETInstalled
public static Version NET
{
get
{
FillNetInstalled();
string
clr = String.Format("{0}.{1}", Environment.Version.Major, Environment.Version.Minor);
Version
found = _NETInstalled[_NETInstalled.Keys[_NETInstalled.Count-1]];
if(_NETInstalled.ContainsKey(clr))
return _NETInstalled[clr];
for (int i = _NETInstalled.Count - 1; i >= 0; i--)
if (_NETInstalled.Keys[i].CompareTo(clr) < 0)
return found;
else
found = _NETInstalled[_NETInstalled.Keys[i]];
return found;
}
} // NET
}
A partire dalla versione 4.5 Microsoft ha cambiato il modo in cui memorizza l'indicatore di .NET Framework nel registro. La guida ufficiale su come recuperare il framework .NET e le versioni CLR può essere trovata qui: https://msdn.microsoft.com/en-us/library/hh925568(v=vs.110).aspx
Includo la versione modificata del loro codice per affrontare la domanda di generosità su come determinare il framework .NET per 4.5 e versioni successive qui:
using System;
using System.Reflection;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Win32;
namespace stackoverflowtesting
{
class Program
{
static void Main(string[] args)
{
Dictionary<int, String> mappings = new Dictionary<int, string>();
mappings[378389] = "4.5";
mappings[378675] = "4.5.1 on Windows 8.1";
mappings[378758] = "4.5.1 on Windows 8, Windows 7 SP1, and Vista";
mappings[379893] = "4.5.2";
mappings[393295] = "4.6 on Windows 10";
mappings[393297] = "4.6 on Windows not 10";
using (RegistryKey ndpKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32).OpenSubKey("SOFTWARE\\Microsoft\\NET Framework Setup\\NDP\\v4\\Full\\"))
{
int releaseKey = Convert.ToInt32(ndpKey.GetValue("Release"));
if (true)
{
Console.WriteLine("Version: " + mappings[releaseKey]);
}
}
int a = Console.Read();
}
}
}
updatesper NET Framework 4.7 e NET Framework 4.7.1 ?
Questa è la soluzione su cui sono atterrato:
private static string GetDotNetVersion()
{
var v4 = (string)Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full", false)?.GetValue("Version");
if(v4 != null)
return v4;
var v35 = (string)Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP\v3.5", false)?.GetValue("Version");
if(v35 != null)
return v35;
var v3 = (string)Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP\v3.0", false)?.GetValue("Version");
return v3 ?? "< 3";
}
public static class DotNetHelper
{
public static Version InstalledVersion
{
get
{
string framework = null;
try
{
using (var ndpKey =
Registry.LocalMachine.OpenSubKey("SOFTWARE\\Microsoft\\NET Framework Setup\\NDP\\v4\\Full\\"))
{
if (ndpKey != null)
{
var releaseKey = ndpKey.GetValue("Release");
if (releaseKey != null)
{
framework = CheckFor45PlusVersion(Convert.ToInt32(releaseKey));
}
else
{
string[] versionNames = null;
using (var installedVersions =
Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP"))
{
if (installedVersions != null) versionNames = installedVersions.GetSubKeyNames();
}
try
{
if (versionNames != null && versionNames.Length > 0)
{
framework = versionNames[versionNames.Length - 1].Remove(0, 1);
}
}
catch (FormatException)
{
}
}
}
}
}
catch (SecurityException)
{
}
return framework != null ? new Version(framework) : null;
}
}
private static string CheckFor45PlusVersion(int releaseKey)
{
if (releaseKey >= 460798)
return "4.7";
if (releaseKey >= 394802)
return "4.6.2";
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";
// This code should never execute. A non-null release key should mean
// that 4.5 or later is installed.
return releaseKey >= 378389 ? "4.5" : null;
}
}
updatesper NET Framework 4.7 e NET Framework 4.7.1 ?
Se la tua macchina è connessa a Internet, andare su smallestdotnet , scaricare ed eseguire .NET Checker è probabilmente il modo più semplice.
Se hai bisogno del metodo effettivo per determinare la versione guarda la sua fonte su GitHub, esp. il Constants.cs che ti aiuterà per .net 4.5 e versioni successive, dove la parte Revision è quella più recente:
{ int.MinValue, "4.5" },
{ 378389, "4.5" },
{ 378675, "4.5.1" },
{ 378758, "4.5.1" },
{ 379893, "4.5.2" },
{ 381029, "4.6 Preview" },
{ 393273, "4.6 RC1" },
{ 393292, "4.6 RC2" },
{ 393295, "4.6" },
{ 393297, "4.6" },
{ 394254, "4.6.1" },
{ 394271, "4.6.1" },
{ 394747, "4.6.2 Preview" },
{ 394748, "4.6.2 Preview" },
{ 394757, "4.6.2 Preview" },
{ 394802, "4.6.2" },
{ 394806, "4.6.2" },
updatesper NET Framework 4.7 e NET Framework 4.7.1 ?
Trovo più facile lavorare con la Versionclasse:
using Microsoft.Win32;
using System.Runtime.InteropServices;
namespace System.Runtime.InteropServices {
public static class RuntimeInformationEx {
public static Version? GetDotnetFrameworkVersion() {
using var key = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full");
if (key is object) {
if (!Int32.TryParse(key.GetValue("Release", "").ToString(), out var release)) return null;
return release switch
{
378389 => new Version(4, 5, 0),
378675 => new Version(4, 5, 1),
378758 => new Version(4, 5, 1),
379893 => new Version(4, 5, 2),
393295 => new Version(4, 6, 0),
393297 => new Version(4, 6, 0),
394254 => new Version(4, 6, 1),
394271 => new Version(4, 6, 1),
394802 => new Version(4, 6, 2),
394806 => new Version(4, 6, 2),
460798 => new Version(4, 7, 0),
460805 => new Version(4, 7, 0),
461308 => new Version(4, 7, 1),
461310 => new Version(4, 7, 1),
461808 => new Version(4, 7, 2),
461814 => new Version(4, 7, 2),
528040 => new Version(4, 8, 0),
528209 => new Version(4, 8, 0),
528049 => new Version(4, 8, 0),
_ => null
};
} else { // .NET version < 4.5
using var key1 = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP");
if (key1 is null) return null;
var parts = key1.GetSubKeyNames()[^1].Substring(1).Split('.'); // get lastsub key, remove 'v' prefix, and split
if (parts.Length == 2) parts = new string[] { parts[0], parts[1], "0" };
if (parts.Length != 3) return null;
Func<string, int> Parse = s => Int32.TryParse(s, out var i) ? i : -1;
try { return new Version(Parse(parts[0]), Parse(parts[1]), Parse(parts[2])); } catch { return null; }
}
}
public static Version? GetDotnetCoreVersion() {
if (!RuntimeInformation.FrameworkDescription.StartsWith(".NET Core ")) return null;
var parts = RuntimeInformation.FrameworkDescription.Substring(10).Split('.');
if (parts.Length == 2) parts = new string[] { parts[0], parts[1], "0" };
if (parts.Length != 3) return null;
Func<string, int> Parse = s => Int32.TryParse(s, out var i) ? i : -1;
try { return new Version(Parse(parts[0]), Parse(parts[1]), Parse(parts[2])); } catch { return null; }
}
}
}
(il codice è C # 8)
"Release"valori aVersion s. Penso che il punto chiave di dove queste informazioni sono memorizzate nel registro e in quale formato sono ben documentate qui; se questo è presentato al chiamante come string, int, enum, o Versionè tutto solo mettendo un involucro diverso sulla stessa cosa.
var v=RuntimeInformationEx .GetDotnetFrameworkVersion(); if (v<new Version(4,8,0) ...
È possibile ottenere una stringa utile senza dover toccare il registro o gli assembly di riferimento che possono essere caricati o meno. mscorlib.dll e altri assembly di sistema hanno definito AssemblyFileVersionAttribute e sembra essere univoco per ogni versione di .NET, in base agli assembly di riferimento forniti con Visual Studio.
string version = (typeof(string).Assembly
.GetCustomAttributes(typeof(AssemblyFileVersionAttribute), false)
.FirstOrDefault() as AssemblyFileVersionAttribute)?.Version;
La versione 4.5 è un po 'fuori posto, perché è contrassegnata con 4.0 in quella versione, ma dalla 4.6 in poi sembra che la versione minore corrisponda almeno. In questo modo sembra che sarebbe più a prova di futuro che dipendere da una chiave di registro del programma di installazione e dover confrontare con un insieme fisso di valori.
Ho trovato gli assembly di riferimento qui:
C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework
Dove ho ottenuto le seguenti versioni:
4.0 = 4.0.30319.1
4.5 = 4.0.30319.18020
4.5.1 = 4.0.30319.18402
4.5.2 = 4.0.30319.34211
4.6 = 4.6.81.0
4.6.1 = 4.6.1055.0
4.7.2 = 4.7.3062.0
4.8 = 4.8.3761.0
Prova questo:
string GetFrameWorkVersion()
{
return System.Runtime.InteropServices.RuntimeEnvironment.GetSystemVersion();
}
2.0anche se funziona con3.5
RuntimeEnvironment.GetSystemVersion()sembra restituire la versione CLR, non la versione .NET. Pagina MSDN
Environment.Version()probabilmente restituisce solo la versione del CLR.