What’s New With .NET 6 and C# 10

.NET 6.0: Full Summary of What’s New

.NET 6.0, released in November 2021¹, is a major Long-Term Support (LTS) release, marking the completion of the .NET unification journey between .NET Framework with .NET Core. It brings significant improvements in performance, developer productivity, and platform reach, and introduces new features across the entire ecosystem.

First, it unifies the SDK, base libraries, and runtime across cloud, desktop, mobile, IoT, and web apps, making code sharing and cross-platform development easier than ever^{1 2 3}. It brings support for three years, providing stability for enterprise adoption^{1 2}.

We find the following major new features

• Performance Improvements with:

  • Extensive optimizations throughout the runtime and libraries, resulting in faster execution, lower latency, and reduced memory usage^{1 2 4}.
  • FileStream has been rewritten for better async I/O performance, especially on Windows^{1 5 2}.
  • Introduction of dynamic Profile-Guided Optimization (PGO) for runtime-tuned code generation^{1 2 4}.
  • Crossgen2 replaces the original Crossgen tool for more advanced ahead-of-time (AOT) compilation¹.

• Developer Productivity

  • Hot Reload: Make code changes and see them immediately in running apps, without rebuilding or restarting—supported in Visual Studio 2022 and the .NET CLI^{1 5 2 3 6}.
  • Minimal APIs: Build lightweight HTTP APIs with minimal dependencies and code, ideal for microservices and small web services^{1 2 7 3 6}.
  • C# 10: New language features like global usings, file-scoped namespaces, record structs, and improved lambda expressions simplify code and boost productivity^{1 2}. We’ll review the new features with examples later in the article.
  • F# 6: Enhanced async programming, pipeline debugging, and performance improvements².
  • Visual Basic: Improvements to the Visual Studio experience and Windows Forms project handling².

• Cloud and Diagnostics

  • Improved cloud diagnostics with built-in support for OpenTelemetry and dotnet monitor, now production-ready and available in Azure App Service^{8 2}.
  • Enhanced logging with a new source generator for performant logging APIs¹.

• Web and Networking

  • HTTP/3 Support: ASP.NET Core, HttpClient, and gRPC can now interact with HTTP/3 clients and servers, improving network performance and reliability^{2 3 6}.
  • WebAssembly Enhancements: Better performance, native dependencies, and AOT compilation for Blazor WebAssembly apps².
  • Blazor Improvements: Components can be rendered from JavaScript, enabling tighter integration with JS-based apps².
  • Single-Page App (SPA) Pattern: More flexible integration with popular JavaScript frameworks like Angular and React².
  • Async Streaming & W3C Logging: Enhanced support for returning data before response completion and IIS-style logging in ASP.NET Core⁶.

• Cross-Platform and UI

  • .NET MAUI (Multi-platform App UI) Support: Enables building cross-platform apps for Android, iOS, macOS, and Windows from a single codebase^{2 3}.
  • Native Apple Silicon (Arm64) Support: Full native support for Apple M1/M2 chips, as well as improved Windows Arm64 support².

• APIs and Libraries

  • New Reflection APIs: Added types to inspect code for nullability, aiding tools and serializers¹.
  • DateOnly and TimeOnly: New structs for date-only and time-only values, simplifying scenarios like birthdays and business hours¹.
  • Time Zone Enhancements: Support for both IANA and Windows time zone IDs, with automatic conversion and new helper methods¹.
  • LINQ Improvements: New methods and optimizations for querying data^{1 3}.
  • JSON APIs: More capable and higher-performance JSON serialization, including source generation for serializers².

C# 10 New Coding Features with Examples

C# 10, introduced with .NET 6, brings several enhancements that streamline code, improve readability, and boost productivity. Here are some of the most notable features with practical examples.

1. Constant Interpolated Strings

Previously, const strings could not use string interpolation. In C# 10, you can now declare constant interpolated strings as long as all expressions are themselves constants.

1
2
3
4
5

const string Name = "Alan";
const string Designation = $"{Name} - Employee"; // Valid in C# 10

string NameNonConstant = "Alan";
const string Designation = $"{Name} - Employee"; // Invalid in C# 10

2. Global Using Directives

You can now declare using directives as global, making them available across the entire project and eliminating repetitive using statements in every file.

1
2
3

// In GlobalUsings.cs
global using System;
global using System.Collections.Generic;

Now, System and System.Collections.Generic are available everywhere in your project without explicit imports in each file⁹¹⁰.

3. File-Scoped Namespace Declaration

File-scoped namespaces reduce indentation and boilerplate by applying a namespace to the entire file with a single line.

1
2
3
4
5
6

namespace MyProject.Models;

public class Person
{
    public string Name { get; set; }
}

This replaces the older, more verbose block-style namespace^{11 12}.

4. Lambda Improvements

• Natural Types for Lambdas: The compiler can now infer delegate types for lambdas, reducing the need for explicit type declarations.
• Lambda Return Types and Attributes: You can specify return types and apply attributes to lambdas.

1
2
3
4

var numbers = new List { 1, 2, 3, 4, 5 };
var evenNumbers = numbers.Where(x => x % 2 == 0); // Natural type inference

Func add = (int x, int y) => x + y; // Explicit return type if needed

5. File-Scoped Types

You can now declare types that are only accessible within the file using the file modifier.

1
2
3
4

file class InternalHelper
{
    // Only accessible within this file
}

6. Extended Property Patterns

Property patterns in switch expressions are more powerful and concise.

1
2
3
4

if (person is { Address.City: "London" })
{
    // Matches if person's address city is London
}

7. Record Structs

You can now declare record structs for value-type records.

1

public readonly record struct Point(int X, int Y);

8. Assignment and Declaration in Deconstruction

You can declare and assign variables in a single deconstruction statement.

1

(string firstName, string lastName) = GetName();