How to Use C# 8 with Visual Studio 2017

How can I use C# 8 with Visual Studio 2017?

Going forward, Microsoft want to tie C# language versions more closely to framework versions than they have in the past. They really only want you to be using C# 8 with .NET Core 3.x and .NET Standard 2.1 projects, and that means using Visual Studio 2019. My answer to Does C# 8 support the .NET Framework? has all the gory details.

However, if you really want to you can now use C# 8 in Visual Studio 2017 by using the same trick that brings C# 7 to Visual Studio 2015: install the latest version of the Microsoft.Net.Compilers Nuget package into the project. It works, but of course VS 2017 doesn't know about C# 8 syntax so it doesn't look very pretty. Here's a screenshot showing that VS 2017 is able to compile a small test library using nullable reference types and a static local method (both of which are C# 8 features):

enter image description here

Here's the .csproj and code if you want to try it:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFrameworks>netstandard2.0;net452</TargetFrameworks>
    <LangVersion>8.0</LangVersion>    
    <Nullable>enable</Nullable>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.Net.Compilers" Version="3.3.1">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
    </PackageReference>
  </ItemGroup>
</Project>

using System;

namespace CSharp8Test
{
    public class Class1
    {
        public string? NullableString { get; } = "Test";

        public static void Test()
        {
            Console.WriteLine(Test2());
            static int Test2() => 5;
        }
    }
}

Does C# 8 support the .NET Framework?

Yes, C# 8 can be used with the .NET Framework and other targets older than .NET Core 3.0/.NET Standard 2.1 in Visual Studio 2019 (or older versions of Visual Studio if you install a NuGet package).

The only thing required is to set language version to 8.0 in the csproj file. You can also do this in Directory.Build.props to apply it to all projects in your solution. Read below for how to do this in Visual Studio 2019, version 16.3 and newer.

Most - but not all - features are available whichever framework is targeted.

Features that work

The following features are syntax changes only; they work regardless of framework:

Static local functions
Using declarations
Null-coalescing assignment
Readonly members
Disposable ref structs
Positional patterns
Tuple patterns
Switch expressions
Nullable reference types are also supported, but the new nullable attributes required to design the more complex nullable use cases are not. I cover this in more detail further down in the "gory details" section.

Features that can be made to work

These require new types which are not in the .NET Framework. They can only be used in conjunction with "polyfill" NuGet packages or code files:

Asynchronous streams - Microsoft.Bcl.AsyncInterfaces
Indices and ranges

Default interface members - do not, cannot, and never will work

Default interface members won't compile under .NET Framework and will never work because they require runtime changes in the CLR. The .NET CLR is now frozen as .NET Core is now the way forward.

For more information on what does and doesn't work, and on possible polyfills, see Stuart Lang's article, C# 8.0 and .NET Standard 2.0 - Doing Unsupported Things.

Code

The following C# project targetting .NET Framework 4.8 and using C# 8 nullable reference types compiles in Visual Studio 16.2.0. I created it by choosing the .NET Standard Class Library template and then editing it to target .NET Framework instead:

.csproj:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFrameworks>net48</TargetFrameworks>
    <LangVersion>8.0</LangVersion>
    <Nullable>enable</Nullable>
  </PropertyGroup>
</Project>

.cs:

namespace ClassLibrary1
{
    public class Class1
    {
        public string? NullableString { get; set; }
    }
}

I then tried a .NET Framework 4.5.2 WinForms project, using a legacy .csproj format, and added the same nullable reference type property. I changed the language type in the Visual Studio Advanced Build settings dialog (disabled in 16.3) to latest and saved the project. Of course as this point it doesn't build. I opened the project file in a text editor and changed latest to preview in the build configuration PropertyGroup:

<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
   <LangVersion>preview</LangVersion>

I then enabled support for nullable reference types by adding <Nullable>enable</Nullable> to the main PropertyGroup:

<PropertyGroup>
   <Nullable>enable</Nullable>

I reloaded the project, and it builds.

Visual Studio 2019

There has been a major change in the RTM version of Visual Studio 2019 version 16.3, the launch version for C# 8.0: the language selection dropdown has been disabled:

enter image description here

Microsoft's rationale for this is:

Moving forward, ... each version of each framework will have a single
supported and default version, and we won't support arbitrary
versions. To reflect this change in support, this commit permanently
disables the language version combo box and adds a link to a document
explaining the change.

The document which opens is C# language versioning. This lists C# 8.0 as the default language for .NET Core 3.x ONLY. It also confirms that each version of each framework will, going forward, have a single supported and default version and that the framework-agnosticism of the language can no longer be relied on.

The language version can still be forced to 8 for .NET Framework projects by editing the .csproj file.

The gory details

When this answer was first written, C# 8 was in preview and a lot of detective work was involved. I leave that information here for posterity. Feel free to skip it if you don't need to know all the gory details.

The C# language has historically been mostly framework neutral - i.e. able to compile older versions of the Framework - although some features have required new types or CLR support.

Most C# enthusiasts will have read the blog entry Building C# 8.0 by Mads Torgersen, which explains that certain features of C# 8 have platform dependencies:

Async streams, indexers and ranges all rely on new framework types
that will be part of .NET Standard 2.1... .NET Core 3.0 as well as
Xamarin, Unity and Mono will all implement .NET Standard 2.1, but .NET
Framework 4.8 will not. This means that the types required to use
these features won’t be available on .NET Framework 4.8.

This looks a bit like Value Tuples which were introduced in C# 7. That feature required new types - the ValueTuple structures - which were not available in NET Framework versions below 4.7 or .NET Standard older than 2.0. However, C# 7 could still be used in older versions of .NET, either without value tuples or with them by installing the System.ValueTuple Nuget package. Visual Studio understood this, and all was fine with the world.

However, Mads also wrote:

For this reason, using C# 8.0 is only supported on platforms that implement .NET Standard 2.1.

...which if true would have ruled out using C# 8 with any version of the .NET Framework, and indeed even in .NET Standard 2.0 libraries which only recently we were encouraged to use as a baseline target for library code. You wouldn't even be able to use it with .NET Core versions older than 3.0 as they too only support .NET Standard 2.0.

The investigation was on! -

Jon Skeet has an alpha version of Noda-Time using C# 8 ready to go which targets .NET Standard 2.0 only. He is clearly expecting C# 8/.NET Standard 2.0 to support all frameworks in the .NET family. (See also Jon's blog post "First steps with nullable reference types").
Microsoft employees have been discussing the Visual Studio UI for C# 8 nullable reference types on GitHub, and it is stated that they intend to support the legacy csproj (pre-.NET Core SDK format csproj). This is a very strong indication that C# 8 will be usable with the .NET Framework. [I suspect they will backtrack on this now that the Visual Studio 2019 language version dropdown has been disabled and .NET has been tied to C# 7.3]
Shortly after the famous blog post, a GitHub thread discussed cross-platform support. An important point which emerged was that .NET Standard 2.1 will include a marker that denotes that default implementations of interfaces is supported - the feature requires a CLR change that will never be available to the .NET Framework. Here's the important bit, from Immo Landwerth, Program Manager on the .NET team at Microsoft:

Compilers (such as C#) are expected to use the presence of this field to decide whether or not to allow default interface implementations. If the field is present, the runtime is expected to be able to load & execute the resulting code.

This all pointed to "C# 8.0 is only supported on platforms that implement .NET Standard 2.1" being an oversimplification, and that C# 8 will support the .NET Framework but, as there is so much uncertainty, I asked on GitHub and HaloFour answered:

IIRC, the only feature that definitely won't appear on .NET Framework is DIM (default interface methods) as that requires runtime changes. The other features are driven by the shape of classes that might never be added to the .NET Framework but can be polyfilled through your own code or NuGet (ranges, indexes, async iterators, async disposal).

Victor Derks commented that "The new nullable attributes required to design the more complex nullable use cases are only available in System.Runtime.dll that ships with .NET Core 3.0 and .NET Standard 2.1... [and] incompatible with .NET Framework 4.8"
However, Immo Landwerth commented that "The vast majority of our APIs didn't need any custom attributes as the types are either fully generic or not-null" under the article Try out Nullable Reference Types
Ben Hall raised the issue Availability of nullable attributes outside of Core 3.0 on GitHub, with the following comments from Microsoft employees being of note:

C# 8 will be fully supported on .net core 3.0 and .net standard 2.1 only.
If you manually edit the project file to use C# 8 with .net core 2.1,
you are in unsupported territory. Some C# 8 features will happen to
work well, some C# 8 features will work not too well (e.g. poor
performance), some C# 8 features will work with extra hacks, and some
C# 8 features will not work at all. Very complex to explain. We do not
actively block it so the expert users who can navigate through it can
do so. I would not recommend this unsupported mix&match to be used
broadly.

(Jan Kotas)

People like you who are willing understand -- and work around them --
are free to use C# 8. The point is, not all language features will work
on down-level targets.

(Immo Landwerth)

Caveat emptor

The C# 8/.NET Framework combination is not officially supported by Microsoft. It is, they say, for experts only.

Feature 'using declarations' is not available in C# 7.3. Please use language version 8.0 or greater - Error on one machine but works on another

This can be because the compiler uses by default different C# language versions for different Target Frameworks.

To override the default C# language, add to project file (as suggested in question):

<PropertyGroup>
   <LangVersion>8.0</LangVersion>
</PropertyGroup>

or:

<PropertyGroup>
   <LangVersion>latest</LangVersion>
</PropertyGroup>

Note: It is not recommended to use a language version newer than the default.

From C# language versioning - Microsoft Docs (as of 03/11/2022):

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.

See C# language versioning - Microsoft Docs for the default C# language versions for the different target frameworks and how to manually select the C# language version.

See also the stack overflow answer Does C# 8 support the .NET Framework? for more information on this topic.

Here is part of the C# language versioning - Microsoft Docs article (as of 03/11/2022) which explains about the default language versions for different target frameworks:

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.
C# 10 is supported only on .NET 6 and newer versions. C# 9 is supported only on .NET 5 and newer versions. C# 8.0 is supported only on .NET Core 3.x and newer versions.
...
Defaults
The compiler determines a default based on these rules:
╔══════════════════╦═════════╦═════════════════════════════╗
║ Target framework ║ version ║ C# language version default ║
╠══════════════════╬═════════╬═════════════════════════════╣
║ .NET             ║ 6.x     ║ C# 10                       ║
║ .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                      ║
╚══════════════════╩═════════╩═════════════════════════════╝

Relationship between C# 8.0, NET Core 3.0 and Visual Studio

Update after release of .NET Core 3

Some features added in C# 8.0 require .NET Core 3.0, so these have a tighter relationship than C#/.NET had before. The pair can be acquired as a workload through VS, but keep in mind C# 8.0 and .NET Core 3.0 don't require VS; you can use these in other IDEs.

The C# language versioning document describes the language/.NET relationships in more detail.

For some pragmatic details, you can read how to target C# 8.0 in Visual Studio.

Old Answer

Take a look at An update to C# versions and C# tooling, which provides a good insight about the language as it relates to projects in Visual Studio.

In particular,

The default language version chosen in this scenario is Preview. The C# 8.0 features you have access to are based entirely on the version of the compiler (and thus the .NET SDK) that you are using. As you use future previews, you may get more (or slightly tweaked) features. When you build a project, the .NET SDK will emit a warning that this is all still in preview.

In answer to

What is the relationship between C# 8.0, NET Core 3.0 and Visual Studio?

The relationship between language, SDK, and Visual Studio version are much looser than they used to be. The language can evolve independent of .NET in any of its incarnations. That doesn't mean that will always be true. Visual Studio too is independent of language and framework. If you take a look at the Visual Studio Installer, you will see that language and .NET support are "workloads" that can be installed. The SDK exposes the language features and VS offers the tooling.

If you're going with VS 2017 for now, take a look at

SO Q&A on .NET Core 3.0 and VS 2017
This article on C# 8.0 in VS 2017

As a followup, I'm also confused as to what a new language version actually is in terms of physical deployment

It's the SDK that contains the compiler that can create the assemblies from C# 8.0 source.

Is it new assemblies deployed as part of a new visual studio deploy, or part of a net core sdk install or something else?

Part of the SDK, see above. This means nothing is "deployed" in addition to your code. Your code, whatever the version, targets a version of .NET. That said, the targeted version of .NET must exist on the machine or container.

Does C# 8 need to be added to both full framework and .NET Core?

It doesn't "need to be added". The newer versions of this framework (4.8) and SDK (.NET Core 3.0) come with C# 8.0 support.

.NET Framework 4.8 seems to use C# version older than 7

I used a comment to formulate the answer. I checked the csproj file and searched for LangVersion.

<LangVersion>6</LangVersion>

Removing the line solved the problem.

The language version nowadays is based on the .NET framework version and is not separately specified.

You cannot set the language version in the projects advanced properties, but the setting seems to be respected despite that.

How to change C# Language Version for all of the projects in my solution in one place?

To set a version for all your project at once, you can create a file named Directory.Build.props (case-sensitive on Linux) at the root of your repository. This file contains the list of common properties of your projects:

<Project>
  <PropertyGroup>
    <LangVersion>latest</LangVersion>
    <!--<LangVersion>preview</LangVersion>-->
    <!--<LangVersion>7.3</LangVersion>-->
  </PropertyGroup>
</Project>

https://www.meziantou.net/4-ways-to-enable-the-latest-csharp-features.htm#method-4-using-a-pro

How do I create a C# 8.0 Console application?

Open your csproj and see if you have a line like

    <LangVersion>7.3</LangVersion>

If yes try removing it, if that doesn't work try to change it to 8.0

From https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/configure-language-version#defaults

You should remove the
<LangVersion>latest</LangVersion> from your project file when you
update the .NET SDK.

Show 3.0 Framework in TargetFramework on Visual Studio 2017

https://dotnet.microsoft.com/download/dotnet-core/3.0

.NET Core 3.0 and above is exclusively available for VS2019. If you cannot upgrade to VS2019, you might use the SDK with tools like VSCode.

You cannot use VS2017, as it won't support things like C# 8.

You didn't see 2.2 due to another issue, .NET Core 2.2 Can't be Selected In Visual Studio Build Framework

Use Visual Studio 2017 with .Net Core SDK 3.0

.In VS 2017: You can just go to the Tools → Options → Project and Solutions → .NET Core and then check Use previews of the .NET Core SDK