The problem is that I need to know if it's version 3.5 SP 1. Environment.Version() only returns 2.0.50727.3053.
I found this solution, but I think it will take much more time than it's worth, so I'm looking for a simpler one. Is it possible?
Is there an easy way to check the .NET Framework version?
Viewed 128361
23 Answers
Something like this should do it. Just grab the value from the registry
For .NET 1-4:
Framework is the highest installed version, SP is the service pack for that version.
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));
For .NET 4.5+ (from official documentation):
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 >= 528040) {
return "4.8 or later";
}
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";
}
Environment.Version() is giving the correct answer for a different question. The same version of the CLR is used in .NET 2.0, 3, and 3.5. I suppose you could check the GAC for libraries that were added in each of those subsequent releases.
It used to be easy, but Microsoft decided to make a breaking change: Before version 4.5, each version of .NET resided in its own directory below C:\Windows\Microsoft.NET\Framework (subdirectories v1.0.3705, v1.1.4322, v2.0.50727, v3.0, v3.5 and v4.0.30319).
Since version 4.5 this has been changed: Each version of .NET (i.e. 4.5.x, 4.6.x, 4.7.x, 4.8.x, ...) is being installed in the same subdirectory v4.0.30319 - so you are no longer able to check the installed .NET version by looking into Microsoft.NET\Framework.
To check the .NET version, Microsoft has provided two different sample scripts depending on the .NET version that is being checked, but I don't like having two different C# scripts for this.
So I tried to combine them into one, here's the script GetDotNetVersion.cs I created (and updated it for 4.7.1 framework):
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
On my machine it outputs:
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
.NET Framework Version: 4.7.2 or later
**** Maximum .NET version number found is: 4.7.2 or later ****
The only thing that needs to be maintained over time is the build number once a .NET version greater than 4.7.1 comes out - that can be done easily by modifying the function CheckFor45PlusVersion, you need to know the release key for the new version then you can add it. For example:
if (releaseKey >= 461308) return "4.7.1 or later";
This release key is still the latest one and valid for the Fall Creators update of Windows 10. If you're still running other (older) Windows versions, there is another one as per this documentation from Microsoft:
.NET Framework 4.7.1 installed on all other Windows OS versions 461310
So, if you need that as well, you'll have to add
if (releaseKey >= 461310) return "4.7.1 or later";
to the top of the function CheckFor45PlusVersion.
Likewise it works for newer versions. For example, I have added the check for 4.8 recently. You can find those build numbers usually at Microsoft.
Note: You don't need Visual Studio to be installed, not even PowerShell - you can use csc.exe to compile and run the script above, which I have described here.
Update: The question is about the .NET Framework, for the sake of completeness I'd like to mention how to query the version of .NET Core as well - compared with the above, that is easy: Open a command shell and type:
dotnet --infoEnter
and it will list the .NET Core version number, the Windows version and the versions of each related runtime DLL as well. Sample output:
.NET Core SDK (reflecting any global.json):
Version: 2.1.300
Commit: adab45bf0c
Runtime Environment:
OS Name: Windows
OS Version: 10.0.15063
OS Platform: Windows
RID: win10-x64
Base Path: C:\Program Files\dotnet\sdk\2.1.300
Host (useful for support):
Version: 2.1.0
Commit: caa7b7e2ba
.NET Core SDKs installed:
1.1.9 [C:\Program Files\dotnet\sdk]
2.1.102 [C:\Program Files\dotnet\sdk]
...
2.1.300 [C:\Program Files\dotnet\sdk]
.NET Core runtimes installed:
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]
To install additional .NET Core runtimes or SDKs:
https://aka.ms/dotnet-download
Note that
if you only need the version number without all the additional information, you can use
dotnet --version.on a 64 bit Windows PC, it is possible to install the x86 version side by side with the x64 version of .NET Core. If that is the case, you will only get the version that comes first in the environment variable
PATH. That is especially important if you need to keep it up to date and want to know each version. To query both versions, use:
C:\Program Files\dotnet\dotnet.exe --version
3.0.100-preview6-012264
C:\Program Files (x86)\dotnet\dotnet.exe --version
3.0.100-preview6-012264
In the example above, both are the same, but if you forgot to update both instances, you might get different results! Note that Program Files is for the 64bit version, and Program Files (x86) is the 32bit version.
Update: If you prefer to keep the build numbers in a list rather than in a cascade of if-statements (as Microsoft suggested), then you can use this code for CheckFor45PlusVersion instead:
private static string CheckFor45PlusVersion(int releaseKey)
{
var release = new SortedDictionary<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)
{
if (k.Key <= releaseKey) result = k.Key; else break;
};
return (result > 0) ? release[result] : "No 4.5 or later version detected";
}
I had a situation where my .NET 4.0 class library might be called from an .NET 4.0 or higher version assemblies.
A specific method call would only work if executed from an 4.5+ assembly.
In Order to decide if I should call the method or not I needed to determine the current executing framework version and this is a pretty good solution for that
var frameworkName = new System.Runtime.Versioning.FrameworkName(
AppDomain.CurrentDomain.SetupInformation.TargetFrameworkName
);
if (frameworkName.Version >= new Version(4, 5))
{
// run code
}
Update
this works from a 4.0 assembly
var featureEnabled = GetCurrentFrameworkName().Version >= new Version(4, 5);
public static FrameworkName GetCurrentFrameworkName()
{
// AppDomain.CurrentDomain.SetupInformation.TargetFrameworkName
// is missing prior to .NET 4.5
var targetFrameworkName = (string)AppDomain
.CurrentDomain
.SetupInformation
.GetType()
.GetProperty("TargetFrameworkName")?
.GetValue(AppDomain.CurrentDomain.SetupInformation, null) ?? ".NETFramework,Version=v4.0.0";
return new FrameworkName(targetFrameworkName);
}
AFAIK there's no built in method in the framework that will allow you to do this. You could check this post for a suggestion on determining framework version by reading windows registry values.
You can get a useful string without having to touch the registry or reference assemblies which may or may not be loaded. mscorlib.dll and other System assemblies have AssemblyFileVersionAttribute defined, and it seems to be unique for each version of .NET, based on the reference assemblies provided with Visual Studio.
string version = (typeof(string).Assembly
.GetCustomAttributes(typeof(AssemblyFileVersionAttribute), false)
.FirstOrDefault() as AssemblyFileVersionAttribute)?.Version;
Version 4.5 is a bit off, because it's marked 4.0 in that version, but 4.6 onward appear to have the minor version matching at least. Doing it this way seems like it would be more future proof than depending on some installer registry key and having to compare against a fixed set of values.
I found the reference assemblies here:
C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework
Where I got the following versions:
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
For those looking for all .net-related things' versions.
I combined .net core+framework related info.
namespace DotNetVersions
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("Currently installed \"classic\" .NET Versions in the system:");
//Show all the installed versions
Get1To45VersionFromRegistry();
Get45PlusFromRegistry();
Process p = new Process();
p.StartInfo = new ProcessStartInfo()
{
FileName = "powershell.exe",
Arguments = $"dotnet --info",
UseShellExecute = false,
CreateNoWindow = true,
RedirectStandardOutput = true,
};
p.Start();
string output = p.StandardOutput.ReadToEnd();
p.WaitForExit();
Console.WriteLine(output);
}
//Writes the version
private static void WriteVersion(string version, string spLevel = "")
{
version = version.Trim();
if (string.IsNullOrEmpty(version))
return;
string spLevelString = "";
if (!string.IsNullOrEmpty(spLevel))
spLevelString = " Service Pack " + spLevel;
Console.WriteLine($"{version}{spLevelString}");
}
private static void Get1To45VersionFromRegistry()
{
// Opens the registry key for the .NET Framework entry.
using (RegistryKey ndpKey = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\NET Framework Setup\NDP\"))
{
foreach (string versionKeyName in ndpKey.GetSubKeyNames())
{
// Skip .NET Framework 4.5 version information.
if (versionKeyName == "v4")
{
continue;
}
if (versionKeyName.StartsWith("v"))
{
RegistryKey versionKey = ndpKey.OpenSubKey(versionKeyName);
// Get the .NET Framework version value.
string name = (string)versionKey.GetValue("Version", "");
// Get the service pack (SP) number.
string sp = versionKey.GetValue("SP", "").ToString();
// Get the installation flag, or an empty string if there is none.
string install = versionKey.GetValue("Install", "").ToString();
if (string.IsNullOrEmpty(install)) // No install info; it must be in a child subkey.
WriteVersion(name);
else
{
if (!(string.IsNullOrEmpty(sp)) && install == "1")
{
WriteVersion(name, sp);
}
}
if (!string.IsNullOrEmpty(name))
{
continue;
}
foreach (string subKeyName in versionKey.GetSubKeyNames())
{
RegistryKey subKey = versionKey.OpenSubKey(subKeyName);
name = (string)subKey.GetValue("Version", "");
if (!string.IsNullOrEmpty(name))
sp = subKey.GetValue("SP", "").ToString();
install = subKey.GetValue("Install", "").ToString();
if (string.IsNullOrEmpty(install)) //No install info; it must be later.
WriteVersion(name);
else
{
if (!(string.IsNullOrEmpty(sp)) && install == "1")
{
WriteVersion(name, sp);
}
else if (install == "1")
{
WriteVersion(name);
}
}
}
}
}
}
}
private static void Get45PlusFromRegistry()
{
const string subkey = @"SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full\";
using (RegistryKey ndpKey = Registry.LocalMachine.OpenSubKey(subkey))
{
if (ndpKey == null)
return;
//First check if there's an specific version indicated
if (ndpKey.GetValue("Version") != null)
{
WriteVersion(ndpKey.GetValue("Version").ToString());
}
else
{
if (ndpKey != null && ndpKey.GetValue("Release") != null)
{
WriteVersion(
CheckFor45PlusVersion(
(int)ndpKey.GetValue("Release")
)
);
}
}
}
// Checking the version using >= enables forward compatibility.
string CheckFor45PlusVersion(int releaseKey)
{
if (releaseKey >= 528040)
return "4.8";
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 "";
}
}
}
}
Example output,
Currently installed "classic" .NET Versions in the system:
2.0.50727.4927 Service Pack 2
3.0.30729.4926 Service Pack 2
3.5.30729.4926 Service Pack 1
4.0.0.0
4.8.03761
.NET SDK (reflecting any global.json):
Version: 5.0.102
Commit: 71365b4d42
Runtime Environment:
OS Name: Windows
OS Version: 10.0.17134
OS Platform: Windows
RID: win10-x64
Base Path: C:\Program Files\dotnet\sdk\5.0.102\
Host (useful for support):
Version: 5.0.2
Commit: cb5f173b96
.NET SDKs installed:
1.1.10 [C:\Program Files\dotnet\sdk]
2.1.202 [C:\Program Files\dotnet\sdk]
2.1.402 [C:\Program Files\dotnet\sdk]
2.1.518 [C:\Program Files\dotnet\sdk]
3.0.100 [C:\Program Files\dotnet\sdk]
5.0.102 [C:\Program Files\dotnet\sdk]
.NET runtimes installed:
Microsoft.AspNetCore.All 2.1.4 [C:\Program Files\dotnet\shared\Microsoft.AspNetCore.All]
Microsoft.AspNetCore.All 2.1.22 [C:\Program Files\dotnet\shared\Microsoft.AspNetCore.All]
Microsoft.AspNetCore.All 2.1.24 [C:\Program Files\dotnet\shared\Microsoft.AspNetCore.All]
Microsoft.AspNetCore.All 2.2.1 [C:\Program Files\dotnet\shared\Microsoft.AspNetCore.All]
Microsoft.AspNetCore.App 2.1.4 [C:\Program Files\dotnet\shared\Microsoft.AspNetCore.App]
Microsoft.AspNetCore.App 2.1.22 [C:\Program Files\dotnet\shared\Microsoft.AspNetCore.App]
Microsoft.AspNetCore.App 2.1.24 [C:\Program Files\dotnet\shared\Microsoft.AspNetCore.App]
Microsoft.AspNetCore.App 2.2.1 [C:\Program Files\dotnet\shared\Microsoft.AspNetCore.App]
Microsoft.AspNetCore.App 3.0.0 [C:\Program Files\dotnet\shared\Microsoft.AspNetCore.App]
Microsoft.AspNetCore.App 3.1.11 [C:\Program Files\dotnet\shared\Microsoft.AspNetCore.App]
Microsoft.AspNetCore.App 5.0.2 [C:\Program Files\dotnet\shared\Microsoft.AspNetCore.App]
Microsoft.NETCore.App 1.0.12 [C:\Program Files\dotnet\shared\Microsoft.NETCore.App]
Microsoft.NETCore.App 1.1.9 [C:\Program Files\dotnet\shared\Microsoft.NETCore.App]
Microsoft.NETCore.App 2.0.9 [C:\Program Files\dotnet\shared\Microsoft.NETCore.App]
Microsoft.NETCore.App 2.1.4 [C:\Program Files\dotnet\shared\Microsoft.NETCore.App]
Microsoft.NETCore.App 2.1.22 [C:\Program Files\dotnet\shared\Microsoft.NETCore.App]
Microsoft.NETCore.App 2.1.24 [C:\Program Files\dotnet\shared\Microsoft.NETCore.App]
Microsoft.NETCore.App 2.2.1 [C:\Program Files\dotnet\shared\Microsoft.NETCore.App]
Microsoft.NETCore.App 3.0.0 [C:\Program Files\dotnet\shared\Microsoft.NETCore.App]
Microsoft.NETCore.App 3.1.11 [C:\Program Files\dotnet\shared\Microsoft.NETCore.App]
Microsoft.NETCore.App 5.0.2 [C:\Program Files\dotnet\shared\Microsoft.NETCore.App]
Microsoft.WindowsDesktop.App 3.0.0 [C:\Program Files\dotnet\shared\Microsoft.WindowsDesktop.App]
Microsoft.WindowsDesktop.App 3.1.11 [C:\Program Files\dotnet\shared\Microsoft.WindowsDesktop.App]
Microsoft.WindowsDesktop.App 5.0.2 [C:\Program Files\dotnet\shared\Microsoft.WindowsDesktop.App]
To install additional .NET runtimes or SDKs:
https://aka.ms/dotnet-download
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;
}
}
I find it easier to work with the Version class:
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; }
}
}
}
(code is C#8)
Try this one:
string GetFrameWorkVersion()
{
return System.Runtime.InteropServices.RuntimeEnvironment.GetSystemVersion();
}
Related