A C# 14 újdonságai

A C# 14 az alábbi új funkciókat tartalmazza. Ezeket a funkciókat a Visual Studio 2026 legújabb verziójával vagy a .NET 10 SDK-val is kipróbálhatja:

A C# 14 a legújabb C# kiadás. A C# 14 támogatást élvez .NET 10-en. További információért lásd: C# nyelv verziószámozás.

A legújabb .NET 10 SDK-t a .NET letöltési oldaláról töltheti le. Letöltheti a Visual Studio 2026-ot is, amely tartalmazza a .NET 10 SDK-t is.

A C# 14-ben bevezetett bármely kompatibilitástörő változást a kompatibilitástörő változásokrólszóló cikkünkben találja.

Megjegyzés

Szeretnénk visszajelzést küldeni ezekről a funkciókról. Ha problémákat talál az új funkciók bármelyikével kapcsolatban, hozzon létre egy új problémát, a dotnet/roslyn adattárban.

Bővítménytagok

A C# 14 új szintaxist ad hozzá a bővítménytagok definiálásához. Az új szintaxis lehetővé teszi a bővítménytulajdonságok deklarálását a bővítménymetelyek mellett. A típust kiterjesztő bővítménytagokat is deklarálhatja a típuspéldány helyett. Más szóval ezek az új bővítménytagok a kiterjesztett típus statikus tagjaiként jelenhetnek meg. Ezek a bővítmények tartalmazhatnak statikus bővítménymetelyként implementált felhasználó által definiált operátorokat. Az alábbi példakód a deklarálható bővítménytagok különböző típusaira mutat példát:

public static class Enumerable
{
    // Extension block
    extension<TSource>(IEnumerable<TSource> source) // extension members for IEnumerable<TSource>
    {
        // Extension property:
        public bool IsEmpty => !source.Any();

        // Extension method:
        public IEnumerable<TSource> Where(Func<TSource, bool> predicate) { ... }
    }

    // extension block, with a receiver type only
    extension<TSource>(IEnumerable<TSource>) // static extension members for IEnumerable<Source>
    {
        // static extension method:
        public static IEnumerable<TSource> Combine(IEnumerable<TSource> first, IEnumerable<TSource> second) { ... }

        // static extension property:
        public static IEnumerable<TSource> Identity => Enumerable.Empty<TSource>();

        // static user defined operator:
        public static IEnumerable<TSource> operator + (IEnumerable<TSource> left, IEnumerable<TSource> right) => left.Concat(right);
    }
}

Az első bővítményblokk tagjait úgy kezelik, mintha a példány tagjai lennének a IEnumerable<TSource> rendszerben, például sequence.IsEmpty esetében. A második bővítési blokk tagjai úgy vannak meghívva, mintha statikus tagjai lennének IEnumerable<TSource> vagy IEnumerable<int>.Identity például.

További részletekért olvassa el a bővítménytagokkal kapcsolatos cikket a programozási útmutatóban, a kulcsszóraextension vonatkozó nyelvi referenciacikket és az új bővítménytagok funkcióspecifikációját.

A field kulcsszó

A token field lehetővé teszi egy tulajdonság-hozzáférő törzsének megírását explicit háttérmező deklarálása nélkül. A field token egy fordító által szintetizált háttértáblára kerül cserélésre.

Korábban például, ha azt akarta biztosítani, hogy egy string tulajdonság ne lehessen null, deklarálnia kellett egy háttérmezőt, és mindkét elérési metódust (getter és setter) implementálnia kellett.

private string _msg;
public string Message
{
    get => _msg;
    set => _msg = value ?? throw new ArgumentNullException(nameof(value));
}

Mostantól egyszerűbbé teheti a kódot a következőre:

public string Message
{
    get;
    set => field = value ?? throw new ArgumentNullException(nameof(value));
}

A mező alapú tulajdonsághoz deklarálhat törzset az egyik vagy mindkét hozzáférési metódus számára.

Előfordulhat, hogy kompatibilitástörés vagy zavart kelthet a kód olvasása olyan típusokban, amelyek fieldnevű szimbólumot is tartalmaznak. A @field vagy this.field használatával egyértelműsítheti a field kulcsszót és az azonosítót, vagy átnevezheti az aktuális field szimbólumot a jobb megkülönböztetés érdekében.

Implicit tartomány-átalakítások

A C# 14 első osztályú támogatást nyújt a nyelv System.Span<T> és System.ReadOnlySpan<T> számára. Ez a támogatás magában foglalja az új implicit átalakításokat, amelyek lehetővé teszik az ilyen típusú természetes programozást.

Span<T> és ReadOnlySpan<T> számos kulcsfontosságú módon használt a C#-ban és a futtatókörnyezetben. Bevezetésük a biztonság veszélyeztetése nélkül javítja a teljesítményt. A C# 14 felismeri a kapcsolatot, és támogatja a ReadOnlySpan<T>, Span<T>és T[]közötti átalakításokat. A span típusok lehetnek bővítménymetódus-fogadók, összekapcsolódhatnak más átalakításokkal, és segíthetnek általános típusú következtetési forgatókönyvekben.

Az implicit span konverziók listáját a nyelvi referencia szakaszban beépített típusok című cikkben találja. További részletekért olvassa el első osztályú spantípusokfunkcióspecifikációját.

Kötetlen általános típusok és nameof

C# 14-től kezdődően a nameof argumentuma lehet kötetlen generikus típus. Például a nameof(List<>) értéke List lesz. A C# korábbi verzióiban csak a lezárt általános típusok( például List<int>) használhatók a List nevének visszaadására.

Egyszerű lambdaparaméterek módosítókkal

Paramétermódosítókat, például scoped, ref, in, outvagy ref readonly adhat hozzá a lambda kifejezés paramétereihez a paramétertípus megadása nélkül:

delegate bool TryParse<T>(string text, out T result);
// ...
TryParse<int> parse1 = (text, out result) => Int32.TryParse(text, out result);

Korábban a módosítók hozzáadása csak akkor volt engedélyezett, ha a paraméterdeklarációk tartalmazzák a paraméterek típusait. Az előző deklaráció minden paraméterhez típusokat igényel:

TryParse<int> parse2 = (string text, out int result) => Int32.TryParse(text, out result);

A params módosítóhoz továbbra is explicit módon beírt paraméterlista szükséges.

Ezekről a változásokról a C# nyelvi referencia lambdakifejezésekről szóló cikkben olvashat bővebben.

Még több részleges tag

Mostantól példánykonstruktorokat és eseményeketrészleges tagokkéntdeklarálhatja.

A részleges konstruktoroknak és a részleges eseményeknek pontosan egy definíciós deklarációt és egy megvalósító deklarációtkell, hogy tartalmazzanak.

Csak részleges konstruktor implementálási deklarációja tartalmazhat konstruktor inicializálót: this() vagy base(). Csak egy részleges típusdeklaráció tartalmazhatja az elsődleges konstruktor szintaxisát.

A részleges esemény deklarációjának tartalmaznia kell a add és remove hozzáférőket. A definiáló deklaráció mezőszerű eseményt deklarál.

Felhasználó által definiált összetett hozzárendelés

A felhasználó által definiált összetett hozzárendelés funkcióspecifikációjában többet is megtudhat.

Nulla-feltételes hozzárendelés

A null feltételes tag hozzáférési operátorai, ?. és ?[]mostantól egy hozzárendelés vagy összetett hozzárendelés bal oldalán is használhatók.

A C# 14 előtt null értékűen kellett ellenőriznie egy változót egy tulajdonsághoz való hozzárendelés előtt:

if (customer is not null)
{
    customer.Order = GetCurrentOrder();
}

Az operátorral ?. egyszerűsítheti az előző kódot:

customer?.Order = GetCurrentOrder();

Az operátor jobb oldala = csak akkor lesz kiértékelve, ha a bal oldal nem null. Ha customer null, a kód nem hívja meg GetCurrentOrder.

A hozzárendelés mellett null feltételes taghozzáférés-operátorokat is használhat összetett hozzárendelési operátorokkal (+=, -= és másokkal). A növekmény ++ és a dekrementum -- azonban nem engedélyezett.

A feltételes tagok hozzáféréséről és a null feltételes hozzárendelés funkciós specifikációiról a nyelvi referenciacikkben talál további információt.

Lásd még

  • Last updated on