CODEWITHSUNDEEP
c#
grrussel
grrussel

Reputation: 7339

How can compilation of C# code be made to require a given language or compiler version?

How can a C# program detect it is being compiled under a version of C# that does not contain support for the language features used in that program?

The C# compiler will reject the program, and produce some error message, on encountering the features of the language it does not support. This does not address the issue, which is to state that the program is being compiled with too old a version of the C# compiler, or a C# compiler that does not support the required version of C#

Ideally, it would be as simple as

#if CS_VERSION < 3
#error CSharp 3 or later is required
#end

Upvotes: 5

Views: 632

Answers (5)

Jon Skeet
Jon Skeet

Reputation: 1502106

I don't believe you can do that with a C# file, but if you're using MSBuild then the project/solution tools version number can stop it from being built with an older version of MSBuild.

Can you give the exact context of this? One "human" solution rather than a technical one might be to try compiling the code with all the "old" versions, and create a document with: "If you get an error like this it probably means you're using the wrong version..."

Another option you might want to consider to make that even simpler is to have a single "required features" file. This would be unused by your main app, but ask users to compile that first. If it works, the rest of your build should work. If it doesn't, it's due to using the wrong version. That's likely to produce a smaller range of errors from different versions (in particular it doesn't have the problem that the compiler could list errors from different files in a random order).

Upvotes: 4

Marc Gravell
Marc Gravell

Reputation: 1063338

There is no predefined symbol for this; you could create your own symbols and define them in your build script. Note that you can fix the language version at the project level:

Project properties -> Build -> Advanced -> Language Version:

  • ISO-1 is C# 1.2
  • ISO-2 is C# 2.0

(maps to the csc /langversion parameter)

But note that this doesn't cover everything - there are a few things that this will let through - particularly in the area of generic type inference. This is only an issue if you need to support old compilers; in which case... test with an old compiler.

For example:

int[] arr1 = { 1, 2, 3, 4, 5 };
string[] arr2 = Array.ConvertAll(arr1, delegate (int i) {return i.ToString();});

This works in .NET 3.5/ISO-2 (pseudo C# 2.0), but doesn't work in .NET 2.0 (proper C# 2.0).

Upvotes: 2

HalliHax
HalliHax

Reputation: 881

Easy: The compiler will fail and give you an error if it can't compile the code.

Upvotes: 2

Richard Anthony Hein
Richard Anthony Hein

Reputation: 10650

Perhaps you can read the supportedRuntime element:

Then you can define the directive you want based on the supportedRuntime, using CSharpProjectConfigurationProperties3.DefineConstants.

You would create a macro in VS to use this.

Upvotes: 0

Jeff Moser
Jeff Moser

Reputation: 20053

According to this list of preprocessor directives, it doesn't seem possible. We usually can tell by using generics (detects 2.0), using auto properties (3.0) or dynamic (4.0)

Upvotes: 3

Related Questions