Megosztás a következőn keresztül:

Nem korlátozott típusparaméter-széljegyzetek

Jegyzet

Ez a cikk egy funkcióspecifikáció. A specifikáció a funkció tervezési dokumentumaként szolgál. Tartalmazza a specifikáció javasolt módosításait, valamint a funkció tervezése és fejlesztése során szükséges információkat. Ezeket a cikkeket mindaddig közzéteszik, amíg a javasolt specifikációmódosításokat nem véglegesítik, és be nem építik a jelenlegi ECMA-specifikációba.

A szolgáltatás specifikációja és a befejezett implementáció között eltérések lehetnek. Ezeket a különbségeket a vonatkozó nyelvi tervezési értekezlet (LDM) megjegyzései rögzítik.

A funkcióspektusok C# nyelvi szabványba való bevezetésének folyamatáról a specifikációkcímű cikkben olvashat bővebben.

Bajnoki probléma: https://github.com/dotnet/csharplang/issues/3297

Összefoglalás

Null értékű széljegyzetek engedélyezése olyan típusparaméterekhez, amelyek nincsenek értéktípusokra vagy hivatkozástípusokra korlátozva: T?.

static T? FirstOrDefault<T>(this IEnumerable<T> collection) { ... }

? megjegyzés

A C#8-ban ? széljegyzetek csak olyan típusparaméterekre alkalmazhatók, amelyek kifejezetten értéktípusokra vagy hivatkozástípusokra voltak korlátozva. A C#9-ben ? széljegyzetek bármilyen típusparaméterre alkalmazhatók, a korlátozásoktól függetlenül.

Ha egy típusparaméter nincs kifejezetten értéktípusokra korlátozva, a széljegyzetek csak #nullable enable környezetben alkalmazhatók.

Ha egy T típusparaméter hivatkozástípussal van helyettesítve, akkor a T? az adott referenciatípus null értékű példányát jelöli.

var s1 = new string[0].FirstOrDefault();  // string? s1
var s2 = new string?[0].FirstOrDefault(); // string? s2

Ha T értéktípussal helyettesít, akkor T? a Tegy példányát jelöli.

var i1 = new int[0].FirstOrDefault();  // int i1
var i2 = new int?[0].FirstOrDefault(); // int? i2

Ha T helyére egy annotált U?kerül, akkor T?U?helyett az annotált típust U?? jelöli.

var u1 = new U[0].FirstOrDefault();  // U? u1
var u2 = new U?[0].FirstOrDefault(); // U? u2

Ha T egy Utípussal helyettesít, akkor T?U?jelöl, még egy #nullable disable környezetben is.

#nullable disable
var u3 = new U[0].FirstOrDefault();  // U? u3

Visszatérési értékek esetén a T? egyenértékű a [MaybeNull]T; argumentumértékek esetén T? egyenértékű a [AllowNull]T. Az egyenértékűség akkor fontos, ha egy C#8-tal összeállított szerelvény interfészeit felül kell bírálni vagy implementálni.

public abstract class A
{
    [return: MaybeNull] public abstract T F1<T>();
    public abstract void F2<T>([AllowNull] T t);
}

public class B : A
{
    public override T? F1<T>() where T : default { ... }       // matches A.F1<T>()
    public override void F2<T>(T? t) where T : default { ... } // matches A.F2<T>()
}

default kényszer

A meglévő kóddal való kompatibilitás érdekében, ahol a felülírt és explicit módon implementált általános metódusok nem tartalmazhatnak explicit korlátozó záradékokat, a felülírt vagy explicit implementált metódusokban T?Nullable<T>-ként van kezelve, ha a T értéktípus.

A referenciatípusokra korlátozott típusparaméterek annotációinak engedélyezéséhez a C#8 explicit where T : class és where T : struct korlátozásokat engedélyezett a felülbírált vagy explicit módon implementált metódusokra vonatkozóan.

class A1
{
    public virtual void F1<T>(T? t) where T : struct { }
    public virtual void F1<T>(T? t) where T : class { }
}

class B1 : A1
{
    public override void F1<T>(T? t) /*where T : struct*/ { }
    public override void F1<T>(T? t) where T : class { }
}

Ha olyan típusparaméterek megjegyzéseit szeretné engedélyezni, amelyek nincsenek hivatkozástípusokra vagy értéktípusokra korlátozva, a C#9 új where T : default korlátozást tesz lehetővé.

class A2
{
    public virtual void F2<T>(T? t) where T : struct { }
    public virtual void F2<T>(T? t) { }
}

class B2 : A2
{
    public override void F2<T>(T? t) /*where T : struct*/ { }
    public override void F2<T>(T? t) where T : default { }
}

Hiba, ha nem metódus-felülbíráláson vagy explicit megvalósításon alapuló default kényszert használ. A default kényszer használata akkor hiba, ha a felülírt vagy interfész módszer megfelelő típusparamétere hivatkozástípusra vagy értéktípusra van korlátozva.

Tervezési értekezletek

  • Last updated on