C# language versioning

The latest C# compiler determines a default language version based on your project’s target framework or frameworks. Visual Studio doesn’t provide a UI to change the value, but you can change it by editing the csproj file. The choice of default ensures that you use the latest language version compatible with your target framework. You benefit from access to the latest language features compatible with your project’s target. This default choice also ensures you don’t use a language that requires types or runtime behavior not available in your target framework. Choosing a language version newer than the default can cause hard to diagnose compile-time and runtime errors.

The rules in this article apply to the compiler delivered with Visual Studio 2019 or the .NET SDK. The C# compilers that are part of the Visual Studio 2017 installation or earlier .NET Core SDK versions target C# 7.0 by default.

C# 8.0 is supported only on .NET Core 3.x and newer versions. Many of the newest features require library and runtime features introduced in .NET Core 3.x:

• Default interface implementation requires new features in the .NET Core 3.0 CLR.
• Async streams require the new types System.IAsyncDisposable, System.Collections.Generic.IAsyncEnumerable , and System.Collections.Generic.IAsyncEnumerator .
• Indices and ranges require the new types System.Index and System.Range.
• Nullable reference types make use of several attributes to provide better warnings. Those attributes were added in .NET Core 3.0. Other target frameworks haven’t been annotated with any of these attributes. That means nullable warnings may not accurately reflect potential issues.

C# 9.0 is supported only on .NET 5 and newer versions.

Defaults

The compiler determines a default based on these rules:

Target framework	version	C# language version default
.NET	5.x	C# 9.0
.NET Core	3.x	C# 8.0
.NET Core	2.x	C# 7.3
.NET Standard	2.1	C# 8.0
.NET Standard	2.0	C# 7.3
.NET Standard	1.x	C# 7.3
.NET Framework	all	C# 7.3

When your project targets a preview framework that has a corresponding preview language version, the language version used is the preview language version. You use the latest features with that preview in any environment, without affecting projects that target a released .NET Core version.

Visual Studio 2017 added a latest entry to any project files it created. That meant C# 7.0 when it was added. However, once you upgrade to Visual Studio 2019, that means the latest released version, regardless of the target framework. These projects now override the default behavior. You should edit the project file and remove that node. Then, your project will use the compiler version recommended for your target framework.

Override a default

If you must specify your C# version explicitly, you can do so in several ways:

To know what language version you’re currently using, put #error version (case sensitive) in your code. This makes the compiler report a compiler error, CS8304, with a message containing the compiler version being used and the current selected language version. See #error (C# Reference) for more information.

Edit the project file

You can set the language version in your project file. For example, if you explicitly want access to preview features, add an element like this:

The value preview uses the latest available preview C# language version that your compiler supports.

Configure multiple projects

To configure multiple projects, you can create a Directory.Build.props file that contains the element. You typically do that in your solution directory. Add the following to a Directory.Build.props file in your solution directory:

Builds in all subdirectories of the directory containing that file will use the preview C# version. For more information, see Customize your build.

C# language version reference

The following table shows all current C# language versions. Your compiler may not necessarily understand every value if it’s older. If you install the latest .NET SDK, then you have access to everything listed.

Value	Meaning
preview	The compiler accepts all valid language syntax from the latest preview version.
latest	The compiler accepts syntax from the latest released version of the compiler (including minor version).
latestMajor ( default )	The compiler accepts syntax from the latest released major version of the compiler.
9.0	The compiler accepts only syntax that is included in C# 9.0 or lower.
8.0	The compiler accepts only syntax that is included in C# 8.0 or lower.
7.3	The compiler accepts only syntax that is included in C# 7.3 or lower.
7.2	The compiler accepts only syntax that is included in C# 7.2 or lower.
7.1	The compiler accepts only syntax that is included in C# 7.1 or lower.
7	The compiler accepts only syntax that is included in C# 7.0 or lower.
6	The compiler accepts only syntax that is included in C# 6.0 or lower.
5	The compiler accepts only syntax that is included in C# 5.0 or lower.
4	The compiler accepts only syntax that is included in C# 4.0 or lower.
3	The compiler accepts only syntax that is included in C# 3.0 or lower.
ISO-2 (or 2 )	The compiler accepts only syntax that is included in ISO/IEC 23270:2006 C# (2.0).
ISO-1 (or 1 )	The compiler accepts only syntax that is included in ISO/IEC 23270:2003 C# (1.0/1.2).

Open Visual Studio Developer Command Prompt or Visual Studio Developer PowerShell, and run the following command to see the listing of language versions available on your machine.

Querying the **LangVersion compile option like this prints something similar to the following:

Windows version in c# [duplicate]

I want to know which Windows version the PC has.. in C# Framework 3.5

I have tried using

OperatingSystem os = Environment.OSVersion;

Version ver = os.Version;

But the result is

Version minor: 2

The problem is that I have «Windows 8 Pro».

How can I detect it?

4 Answers 4

You will have to match version numbers with the appropriate string value yourself.

Here is a list of the most recent Windows OS and their corresponding version number:

• Windows Server 2016 Technical Preview — 10.0*
• Windows 10 — 10.0*
• Windows 8.1 — 6.3*
• Windows Server 2012 R2 — 6.3*
• Windows 8 — 6.2
• Windows Server 2012 — 6.2
• Windows 7 — 6.1
• Windows Server 2008 R2 — 6.1
• Windows Server 2008 — 6.0
• Windows Vista — 6.0
• Windows Server 2003 R2 — 5.2
• Windows Server 2003 — 5.2
• Windows XP 64-Bit Edition — 5.2
• Windows XP — 5.1
• Windows 2000 — 5.0

*For applications that have been manifested for Windows 8.1 or 10. Applications not manifested for 8.1 / 10 will return the Windows 8 OS version value (6.2).

Also, from the same source:

Identifying the current operating system is usually not the best way to determine whether a particular operating system feature is present. This is because the operating system may have had new features added in a redistributable DLL. Rather than using the Version API Helper functions to determine the operating system platform or version number, test for the presence of the feature itself.

How to get the current product version in C#?

How can I programmatically get the current product version in C#?

I am getting VersionNumber=1.0.0.0, but the current version is 1.0.0.12.

9 Answers 9

There are three versions: assembly, file, and product. To get the product version:

I got the answer to my question its Just give the reference to System.Deployment.Application and though it wont work in developement of the visual studio but it will work once the application is deployed.

Another approach to getting the product version (which is specified using the AssemblyInformationalVersionAttribute ) is

Also, see this Microsoft Doc on the AssemblyName.Version property.

All these answers ask for the assembly with .GetExecutingAssembly() .
If you have this code in a dll, it will return the dll version number.

Swap that call for GetCallingAssembly() to get the place in your code that wanted to know.

In C# you need to use reflection and diagnostics

I had the same issue as most of you. It would always show 1.0.0.0 unless you manually went in and updated assemblyInfo.cs to the version you wanted to display. I think we wanted to display the publish version-revision number under the project properties but that doesn’t seem to be an option (from what I’ve read).

I’m not sure if back when these comments were made this existed, but now in the assemblyinfo.cs there is a way to do this automatically. I too was not content with having to manually update these with every publish.

// You can specify all the values or you can default the Build and Revision Numbers // by using the ‘*’ as shown below: // [assembly: AssemblyVersion(«1.0.*»)] [assembly: AssemblyVersion(«1.0.*»)]

That * auto-increments with each publish. It won’t be the same as the publish number you see under the project properties, but it definitely increments and is definitely better than doing it by hand.

You then have a couple options to display it as mentioned above. I personally used this which I found on another site

How to get the “friendly” OS Version Name?

I am looking for an elegant way to get the OS version like: «Windows XP Professional Service Pack 1» or «Windows Server 2008 Standard Edition» etc.

Is there an elegant way of doing that?

I am also interested in the processor architecture (like x86 or x64).

12 Answers 12

You can use WMI to get the product name («Microsoft® Windows Server® 2008 Enterprise «):

You should really try to avoid WMI for local use. It is very convenient but you pay dearly for it in terms of performance. This is quick and simple:

Why not use Environment.OSVersion ? It will also tell you what operating this is — Windows, Mac OS X, Unix, etc. To find out if you are running in 64bit or 32bit, use IntPtr.Size — this will return 4 bytes for 32bit and 8 bytes for 64bit.

Try:

Output:

Microsoft Windows 10 Enterprise

Note: Add reference to Microsoft.VisualBasic.Devices;

Source code for OSInfo class: http://www.csharp411.com/determine-windows-version-and-edition-with-c/ However there is an error in the code, you will need to replace the «case 6» statement (it’s just before #endregion NAME) with this:

And if you want to go a step further and see if your program is running in 64 or 32 bit:

Little late, but this is how I did it. Might help someone in the future.

For me below line works which gives me output like: Microsoft Windows 10.0.18362

FrameworkDescription : Returns a string that indicates the name of the .NET installation on which an app is running.

OSArchitecture : Gets the platform architecture on which the current app is running.

OSDescription : Gets a string that describes the operating system on which the app is running.

ProcessArchitecture : Gets the process architecture of the currently running app.

One thing to be careful of is this information is usually localized and will report differently depending on the language of the OS.

You can get a lot of info from WMI look for the Win32_OperatingSystem class

Note that the processor architecture question is complex:

do you mean (higher numers require lower numbers to be true):

1. The CPU is capable for handling 64bit (in the sense that it supports AMD/intel x64 or Itanium)
2. The Operating system is 64bit
   • GPR and pointers are 64bits, i.e. XP 64, Vista 64, a 64 bit server release or a 64bit OS for mono
3. The currently executing process is a 64 bit process (not executing under Wow64 for example)

if you are happy that all 3 must be true then

Detect Windows version in .net

How can I detect the Windows OS versions in .net?

What code can I use?

15 Answers 15

System.Environment.OSVersion has the information you need for distinguishing most Windows OS major releases, but not all. It consists of three components which map to the following Windows versions:

For a library that allows you to get a more complete view of the exact release of Windows that the current execution environment is running in, check out this library.

Important note: if your executable assembly manifest doesn’t explicitly state that your exe assembly is compatible with Windows 8.1 and Windows 10.0, System.Environment.OSVersion will return Windows 8 version, which is 6.2, instead of 6.3 and 10.0! Source: here.

I used this when I had to determine various Microsoft Operating System versions:

I use the ManagementObjectSearcher of namespace System.Management

Do not forget to add the reference to the Assembly System.Management.dll and put the using: using System.Management;

Result:

Like R. Bemrose suggested, if you are doing Windows 7 specific features, you should look at the Windows® API Code Pack for Microsoft® .NET Framework.

It contains a CoreHelpers class that let you determine the OS you are currently on (XP and above only, its a requirement for .NET nowaday)

It also provide multiple helper methods. For example, suppose that you want to use the jump list of Windows 7, there is a class TaskbarManager that provide a property called IsPlatformSupported and it will return true if you are on Windows 7 and above.

You can use this helper class;

Sample code is here:

This is a relatively old question but I’ve recently had to solve this problem and didn’t see my solution posted anywhere.

The easiest (and simplest way in my opinion) is to just use a pinvoke call to RtlGetVersion

Where Major and Minor version numbers in this struct correspond to the values in the table of the accepted answer.

This returns the correct Windows version number unlike the deprecated GetVersion & GetVersionEx functions from kernel32

Via Environment.OSVersion which «Gets an System.OperatingSystem object that contains the current platform identifier and version number.»

These all seem like very complicated answers for a very simple function:

Detect OS Version:

Then simply do wrap a select case around the function.

1. Add reference to Microsoft.VisualBasic .
2. Include namespace using Microsoft.VisualBasic.Devices ;
3. Use new ComputerInfo().OSFullName

The return value is «Microsoft Windows 10 Enterprise»

The above answers would give me Major version 6 on Windows 10.

The solution that I have found to work without adding extra VB libraries was following:

I wouldn’t consider this the best way to get the version, but the upside this is oneliner no extra libraries, and in my case checking if it contains «10» was good enough.

How about using a Registry to get the name.

«HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion» has a value ProductName since Windows XP.

If you are using .NET Framework 4.0 or above. You can remove the Is64BitOperatingSystem() method and use Environment.Is64BitOperatingSystem.

First solution

To make sure you get the right version with Environment.OSVersion you should add an app.manifest using Visual Studio and uncomment following supportedOS tags:

Then in your code you can use Environment.OSVersion like this:

Example

For instance in my machine ( Windows 10.0 Build 18362.476 ) result would be like this which is incorrect:

By adding app.manifest and uncomment those tags I will get the right version number:

Alternative solution

If you don’t like adding app.manifest to your project, you can use OSDescription which is available since .NET Framework 4.7.1 and .NET Core 1.0.

Note: Don’t forget to add following using statement at top of your file.

You can read more about it and supported platforms here.