Nyheter i C# 15

C# 15 innehåller följande nya funktioner. Prova dessa funktioner med den senaste Visual Studio 2026 insiders-versionen eller .NET 11 preview SDK:

• Argument för samlingsuttryck
• Union-typer
• Stängda hierarkier
• Minnessäkerhet

C# 15 är den senaste C#-förhandsversionen. Förhandsversioner av .NET 11 stöder C# 15. Mer information finns i C#-språkversioner.

Du kan ladda ned den senaste förhandsversionen av .NET 11 SDK från nedladdningssidan för .NET. Du kan också ladda ned Visual Studio 2026 insiders, som innehåller .NET 11 preview SDK.

Sidan "Nyheter i C#" lägger till nya funktioner när de är tillgängliga i offentliga förhandsversioner. Arbetsuppsättningsavsnittet på roslyn-funktionsstatussidan spårar när kommande funktioner slås samman till huvudgrenen.

Du hittar eventuella icke-bakåtkompatibla ändringar som introduceras i C# 15 i vår artikel om icke-bakåtkompatibla ändringar.

Argument för samlingsuttryck

Du kan skicka argument till den underliggande samlingens konstruktor eller fabriksmetod genom att använda ett with(...) element som det första elementet i ett samlingsuttryck. Med den här funktionen kan du ange kapacitet, jämförelsetal eller andra konstruktorparametrar direkt i syntaxen för samlingsuttryck.

I följande exempel visas hur du skickar ett kapacitetsargument till en List<T> konstruktor och en jämförelse med en HashSet<T>:

string[] values = ["one", "two", "three"];

// Pass capacity argument to List<T> constructor
List<string> names = [with(capacity: values.Length * 2), .. values];

// Pass comparer argument to HashSet<T> constructor
HashSet<string> set = [with(StringComparer.OrdinalIgnoreCase), "Hello", "HELLO", "hello"];
// set contains only one element because all strings are equal with OrdinalIgnoreCase

Mer information om argument för samlingsuttryck finns i språkreferensartikeln om samlingsuttryck eller funktionsspecifikationen. Information om hur du använder argument för samlingsuttryck i insamlingsinitierare finns i Initiatorer för objekt och samling.

Union-typer

C# 15 introducerar union typer, som representerar ett värde som kan vara en av flera falltyper. Deklarera en union med nyckelordet union :

public record class Cat(string Name);
public record class Dog(string Name);
public record class Bird(string Name);

public union Pet(Cat, Dog, Bird);

Unioner tillhandahåller implicita konverteringar från varje falltyp, och kompilatorn garanterar att switch uttrycken omfattar alla falltyper.

Pet pet = new Dog("Rex");

string name = pet switch
{
    Dog d => d.Name,
    Cat c => c.Name,
    Bird b => b.Name,
};

Körningsmiljön innehåller typerna UnionAttribute och IUnion från och med .NET 11 Preview 5. Vissa funktioner från förslagsspecifikationen har ännu inte implementerats. Dessa funktioner kommer i framtida förhandsversioner.

Mer information finns i Unionstyper i språkreferensen eller funktionsspecifikationen.

Stängda hierarkier

Från och med C# 15 kan du tillämpa closed modifieraren på en klass för att deklarera en stängd hierarki. En förseglad klass kan endast härledas inom den sammanställning där den deklareras, vilket fastställer mängden direkt härledda klasser vid kompilering:

public closed record class GateState;
public record class Closed : GateState;
public record class Open(float Percent) : GateState;

Eftersom kompilatorn känner till varje direkt underordnad är ett switch uttryck som hanterar var och en fullständig och inte behöver någon standardarm:

string Describe(GateState state) => state switch
{
    Closed => "closed",
    Open(var percent) => $"{percent}% open",
    // No warning: every direct descendant of 'GateState' is handled.
};

Modifieraren closed är ett kontextuellt nyckelord. En closed klass är implicit abstract och kan inte kombineras med sealed, staticeller en explicit abstract modifierare. Härledning är inte transitiv: en icke-sluten underordnad till en sluten klass kan fortfarande härledas från i andra sammansättningar. Om du vill utöka den uttömmande kontrollen längre ned i hierarkin markerar du även mellanliggande efterföljande typer closed.

namespace System.Runtime.CompilerServices;

[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
public sealed class ClosedAttribute : Attribute { }

Mer information finns i mönster för stängda modifierare och Stängd hierarki i språkreferensen eller funktionsspecifikationen. Du kan kopiera exemplen i det här avsnittet, inklusive ClosedAttribute-lösningen, från keywords snippets-projektet i dotnet/docs GitHub-lagringsplatsen.

Minnessäkerhet

C# 15 påbörjar en multirelease-insats för att omdefiniera minnessäkerheten på språket. Målet är att knyta kontexten unsafe till de operationer som faktiskt får åtkomst till ohanterat minne, snarare än till pekartypernas existens. De flesta sårbarheter kopplade till minnessäkerhet kommer från dessa åtkomstoperationer, så språket gör dem tydliga för granskare och revisorer.

I den kompletta modellen markerar unsafe på en medlem den som requires-unsafe: granskningsansvaret övergår till anroparen, som måste använda medlemmen i en unsafe-kontext. En sammansättning väljer detta och kompilatorn registrerar valet med attributet System.Runtime.CompilerServices.MemorySafetyRulesAttribute . Modellen lägger också till ett safe kontextuellt nyckelord som markerar extern medlemmar och fält med explicit layout som säkra. Tillsammans gör dessa regler gränserna för potentiell minnessäkerhet explicita i ett program.

Det första steget innehåller pekaravslappningar. När du kompilerar med preview språkversionen kräver följande åtgärder inte längre någon unsafe kontext:

• Deklarera en pekartyp och ta adressen till en variabel med operatorn & .
• Satsen fixed, som låser en variabels plats i minnet.
• Konvertera ett stackalloc uttryck till en pekare.
• Operatorn sizeof tillämpades på alla ohanterade typer.

I följande exempel skapas och fästs en pekare utan kontext unsafe :

int number = 42;
int* pointer = &number;

int[] numbers = [10, 20, 30];
fixed (int* first = numbers)
{
    // Dereferencing the pointer still requires an unsafe context.
}

De åtgärder som får åtkomst till minnet som pekaren pekar på, till exempel pekarindirektion (*p), medlemsåtkomst via pekare (p->member), elementåtkomst via pekare (p[i]) och anrop av funktionspekare, kräver fortfarande ett unsafe-sammanhang.

Medlemsmodellen requires-unsafe, att assemblyn väljer att använda de uppdaterade minnessäkerhetsreglerna, och det kontextuella nyckelordet safe kommer i en senare förhandsversion.

Mer information finns i Osäker kod, pekartyper och funktionspekare i språkreferensen eller funktionsspecifikationen.

Se även

• Vad är nytt i .NET 11