Develop Reference

Migrate from .net standard to .net 6 using the upgrade tool

I tried upgrading a .NET standard project to a .NET 6 project using this upgrade assistant tool:
https://dotnet.microsoft.com/en-us/platform/upgrade-assistant/tutorial/install-upgrade-assistant
I ran the tool as the steps describe (installing it, using upgrade-assistant analyze with the project csproj path and then upgrade-assistant upgrade with the path), but after it was done, the project still remains with a target framework of .net standard 2.0.
Is there something else needs to be done in order to upgrade the framework?

I eventually simply edited the project file directly. To convert it to .net 6 all you need to do is change the <TargetFramework> to be like this:
<TargetFramework>net6.0</TargetFramework>
It's a 3 seconds work so no need for any tools

.NET standard works parallelly. That means you would have to update to .NET standard 2.1 if you need it for other old framework projects. Otherwise create new libraries in .NET 6 and migrate your code.
According to microsoft:
https://dotnet.microsoft.com/en-us/platform/dotnet-standard,
.NET 6 supports .NET Standard 2.1.
Future versions of .NET will also support .NET Standard 2.1 and earlier versions.

The interface Project > Property tools isn't the way to update version from .Net standard to other versions other than standard versions. The right/easiest way is updating the TargetFramework in .csproj file of the project directly.

Update C# Windows Forms Project to Latest C# Version

I have a C# Windows Forms project but I need to update it to the latest version of the C# language but I don't understand the documentation for updating, does anyone have an example of how to do this?
I'm using version 4.6 of Net Framework, I've tried it with 4.8 too

You can set the LangVersion property in the .csproj file to specify the C# version you'd like to use. You can set it to a specific version, or use "latest" to set it to the latest version compatible with the compiler:
<Project>
<PropertyGroup>
<LangVersion>latest</LangVersion>
</PropertyGroup>
</Project>
Be aware that only certain versions of the C# language are compatible with specific .NET versions and MSBuild Versions. The highest version of C# compatible with .NET Framework is 7.3.
You can find more information, including C# / .NET version compatibility, here:
C# language versioning

Does C# 8 support the .NET Framework?

In Visual Studio 2019 Advanced Build settings, C# 8 does not appear to be available for a .NET Framework project, only (as in the picture below) for a .NET Core 3.0 project:
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:
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.

According to this blog entry the language is indeed tied to the framework:
This means that the types required to use these features won’t be available on .NET Framework 4.8. Likewise, default interface member implementations rely on new runtime enhancements, and we will not make those in the .NET Runtime 4.8 either.
For this reason, using C# 8.0 is only supported on platforms that implement .NET Standard 2.1. The need to keep the runtime stable has prevented us from implementing new language features in it for more than a decade. With the side-by-side and open-source nature of the modern runtimes, we feel that we can responsibly evolve them again, and do language design with that in mind. Scott explained in his Update on .NET Core 3.0 and .NET Framework 4.8 that .NET Framework is going to see less innovation in the future, instead focusing on stability and reliability. Given that, we think it is better for it to miss out on some language features than for nobody to get them.

visual studio 2019 version c# probleme

I can not change the version of C # on visual studio 2019
I tried to go to the property to access a window that normally allowed to change the version of C #
Error CS8025 The 'local functions' feature is not available in C # 4. Use version 7.0 or later.

I'm assuming you're using .Net Core. Within the .csproj file for your start-up project (executable, web, web API, whichever it is in your case), add the following:
<PropertyGroup>
<LangVersion>latest</LangVersion>
</PropertyGroup>
See the docs for more details.

Right click on your csproj in the solution explorer.
Select properties.
Select 'Build' near the top left of the screen.
Click 'Advanced' in the main window (scroll down if you can't see it).
Change language version to latest minor version.

I was not able to edit the language in the property page.
I had to add this to the csproj which was not able to build.
in the propertyGroup, right where AsseblyName is for my .netcore 3 project.
<LangVersion>8</LangVersion>
you should probably use the version according to your .net framework version, the table is here:
The compiler determines a default based on these rules:
DEFAULTS
Target framework 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
source:
https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/configure-language-version

Migrating from .NET 2.0 to .NET 4.0

What are the changes I need to make to a application built with .NET 2.0 /C# in order to use the C# 4.0 features . Recently I ran into a problem, when trying to add optional paramters in a product which was developed on .NET 2.0 / C# 2.0 .

Most 2.0 programs works without any changes on 4.0. It was only on 1.1 to 2.0 that there was a lot of incompatible changes.

One problem, that I ran into recently when upgrading a 3.5 project to 4.0 (Visual Studio 2008 to Visual Studio 2010), was that after upgrading to 4.0 I did not have a reference to System.Core and was unable to add it via Visual Studio instead displaying a message:
A reference to 'System.Core' could not be added. This component is already automatically referenced by the build system.
You will need to have a reference to System.Core if you want to use the var keyword and LINQ extension methods.
It can be manually added (or readded if removed). See the blog post System.Core in VS2010 Projects for details.

Maybe you migrated your Visual Studio solution to 2010, but you forgot to change the target framework to 4.0 in projects' properties.
Just go to properties in your solution projects (obviously, the migrated to Visual Studio 2010 solution) and change the target framework to 4.0.
That's all your C# code base will be using .NET Framework 4.0 and C# 4.0. I'm pretty sure you won't need to change your code, but, maybe, you'll find that some classes, methods, properties are now obsolete, but it'll compile anyway.
Comment out if you don't know how to do that.

In theory, C# 4 should be backwards compatible with C# 2.
In practice, I've done it several times with no problems, and I think the only obvious problem is if you have named some classes that are defined by the .net 4.0 framework.

You cannot use .NET 4.0 specific features in an application targeting .NET 2.0. You will need to migrate to .NET 4.0.

You can't easily convert form a higher version to a lower version.
You can easily convert form a lower version to a higher version.

C# in .NET 2.0 does not support optional parameters if I remember correctly.