How to Check for the C# Version in Your Application
Before writing or executing specific tasks in your application, it is good to be certain of the environment in which you are working. This allows you to determine which packages to use, the specific version, and what features to implement.
Learning about the version can also help you to troubleshoot your application since the error messages and features that you wish to use are specific to that version.
In this tutorial, we will learn how to quickly check the “.NET” version that runs in our C# application using straightforward steps.
Method 1: Cat Project Configuration
One of the most basic yet effective methods of checking the “.NET” version of your application is to check the “.csproj” file.
This XML file contains the definitions and configuration for your project. If you created a C# project using Visual Studio, you can find this file at the root of your project.
In the terminal:
View the “.csproj” file as:
Output:
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net6.0</TargetFramework>
<LangVersion>6.0</LangVersion>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
</Project>
In the resulting output, locate the LangVersion tag which defines the compiler version for your project. In this example, we used the version 6.
Method 2: Using the .NET Runtime Version
We can also use the “Environment.Version” property to fetch the version of the “.NET” runtime that runs for the application.
The “Environment.Version” property returns an object of type “Version” as demonstrated in the following example code:
class Program
{
static void Main()
{
Version version = Environment.Version;
Console.WriteLine("Runtime Version: " + version);
}
}
Once we run the previous code, we should get an output that denotes the version of the “.NET” framework as follows:
In this case, we run the C# version 6.0.
Method 3: Using Reflection
C# has another feature called “reflection” that allows us to inspect the metadata and the invocation of the code during runtime. This lets us quickly gather the information about objects such as the loaded assemblies, their versions, members, methods, properties, fields, and more.
We can use reflection to fetch the C# version for the application as demonstrated in the following example:
using System.Reflection;
class Program
{
static void Main()
{
Assembly assembly = typeof(object).Assembly;
string version = assembly.ImageRuntimeVersion;
Console.WriteLine("Runtime Version: " + version);
}
}
This should return the assembly version as follows:
Method 4: Using the Runtime InteropServices
Lastly, we can use the “RuntimeInformation.FrameworkDescription” property to get a description of the runtime which includes the version number as follows:
using System.Runtime.InteropServices;
class Program
{
static void Main()
{
string framework = RuntimeInformation.FrameworkDescription;
Console.WriteLine("Framework: " + framework);
}
}
Output:
Conclusion
In this tutorial, we covered the four main methods that you can use to check the version of the C# compiler in your program.
Source: linuxhint.com