November 1, 2021 4 min read

.NET 6 GA: The Long-Term Support Release That Changes Everything

.NET 6 is officially here. After two years of development and countless preview releases, Microsoft has shipped the first LTS release in the unified .NET era. This is the version enterprises have been waiting for.

Why .NET 6 Matters

.NET 6 brings together several important milestones:

Long-Term Support: Three years of support, making it suitable for production workloads
Unified Platform: One SDK for web, desktop, mobile, cloud, and IoT
Performance: Significant improvements across the board
C# 10: New language features that improve productivity

Getting Started

Installing .NET 6 is straightforward:

# Download from https://dotnet.microsoft.com/download/dotnet/6.0
# Or using winget on Windows
winget install Microsoft.DotNet.SDK.6

# Verify installation
dotnet --version
# Output: 6.0.100

Creating Your First .NET 6 Application

The new project templates are cleaner than ever:

# Create a new web API
dotnet new webapi -n MyFirstApi
cd MyFirstApi
dotnet run

The generated Program.cs is remarkably minimal:

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();

app.Run();

No Startup.cs, no Main method, no namespace declarations. This is possible thanks to C# 10’s global usings and file-scoped namespaces.

Performance Improvements

.NET 6 brings substantial performance gains. Here’s a simple benchmark showing JSON serialization improvements:

using System.Text.Json;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

[MemoryDiagnoser]
public class JsonBenchmarks
{
    private readonly WeatherForecast _forecast = new()
    {
        Date = DateTime.Now,
        TemperatureC = 25,
        Summary = "Warm"
    };

    [Benchmark]
    public string SerializeJson()
    {
        return JsonSerializer.Serialize(_forecast);
    }

    [Benchmark]
    public WeatherForecast DeserializeJson()
    {
        return JsonSerializer.Deserialize<WeatherForecast>(
            "{\"Date\":\"2021-11-01\",\"TemperatureC\":25,\"Summary\":\"Warm\"}"
        )!;
    }
}

public record WeatherForecast
{
    public DateTime Date { get; init; }
    public int TemperatureC { get; init; }
    public string? Summary { get; init; }
}

In my testing, .NET 6 shows 20-30% improvement in JSON operations compared to .NET 5.

New DateOnly and TimeOnly Types

Finally, we have proper date-only and time-only types:

// Before: Using DateTime for dates felt wrong
DateTime birthdayOld = new DateTime(1990, 5, 15);

// After: DateOnly is semantically correct
DateOnly birthday = new DateOnly(1990, 5, 15);
Console.WriteLine(birthday.ToString("MMMM dd, yyyy")); // May 15, 1990

// TimeOnly for times without dates
TimeOnly openingTime = new TimeOnly(9, 0);
TimeOnly closingTime = new TimeOnly(17, 30);
Console.WriteLine($"Open: {openingTime} - {closingTime}");

// Arithmetic is intuitive
DateOnly nextWeek = birthday.AddDays(7);
TimeOnly lunchTime = openingTime.AddHours(3);

LINQ Enhancements

New LINQ methods reduce boilerplate:

var numbers = Enumerable.Range(1, 100);

// Chunk - split into groups of specified size
var batches = numbers.Chunk(10);
foreach (var batch in batches)
{
    Console.WriteLine($"Batch: {string.Join(", ", batch)}");
}

// TryGetNonEnumeratedCount - get count without iterating if possible
if (numbers.TryGetNonEnumeratedCount(out int count))
{
    Console.WriteLine($"Count: {count}");
}

// MaxBy / MinBy - get element with max/min by selector
var people = new[]
{
    new Person("Alice", 30),
    new Person("Bob", 25),
    new Person("Charlie", 35)
};

var oldest = people.MaxBy(p => p.Age);
var youngest = people.MinBy(p => p.Age);

// FirstOrDefault with custom default
var person = people.FirstOrDefault(p => p.Name == "David", new Person("Unknown", 0));

record Person(string Name, int Age);

File-Scoped Namespaces

C# 10 brings file-scoped namespaces, reducing indentation:

// Before (C# 9)
namespace MyCompany.MyProject.Services
{
    public class UserService
    {
        public User GetUser(int id)
        {
            // Implementation
        }
    }
}

// After (C# 10)
namespace MyCompany.MyProject.Services;

public class UserService
{
    public User GetUser(int id)
    {
        // Implementation
    }
}

Global Usings

No more repeating common using statements in every file:

// In a GlobalUsings.cs file or in your .csproj
global using System;
global using System.Collections.Generic;
global using System.Linq;
global using System.Threading.Tasks;
global using Microsoft.Extensions.Logging;

// Or in .csproj
// <ItemGroup>
//   <Using Include="System.Text.Json" />
// </ItemGroup>

Migrating from .NET 5

Migration is generally straightforward:

Update the target framework:

<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>net6.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>
</Project>

Update NuGet packages to their .NET 6 versions
Address any breaking changes (there are relatively few)

What I’m Excited About

Minimal APIs: Building lightweight services with less ceremony
Hot Reload: Edit code while the app runs
MAUI Preview: Cross-platform UI with a single codebase
Blazor Improvements: Better performance and new features

.NET 6 is the release that proves Microsoft’s commitment to open-source .NET. It’s fast, modern, and ready for production.