Az alias-direktíva használatának engedélyezése bármilyen típusra való hivatkozáshoz

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.

Kiemelt probléma: https://github.com/dotnet/csharplang/issues/8645

Összefoglalás

Lazítsa a using_alias_directive (§13.5.2) hogy bármilyen típusra mutasson, nem csak elnevezett típusokra. Ez támogatná a ma nem engedélyezett típusokat, például: rovátkák, mutatótípusok, tömbtípusok stb. Ez például engedélyezve lesz:

using Point = (int x, int y);

Motiváció

A C# már évek óta képes aliasokat bevezetni a névterekhez és a névvel ellátott típusokhoz (osztályok, delegáltak, felületek, rekordok és szerkezetek). Ez elfogadhatóan működött, mivel lehetővé tette a nem ütköző nevek bevezetését olyan esetekben, amikor az using_directives-ből behúzott normál név nem egyértelmű, és lehetővé tette, hogy egyszerűbb nevet adjon az összetett általános típusok kezelésekor. A nyelv további összetett típusszimbólumainak növekedése azonban több használatot okozott, ahol az aliasok értékesek lennének, de jelenleg nem engedélyezettek. Például a tuples és a függvénymutatók gyakran nagy és összetett normál szöveges űrlapokkal rendelkeznek, amelyek fájdalmasak lehetnek a folyamatos íráshoz, és terhet jelenthetnek az olvasásra. Ezekben az esetekben az aliasok segítenek egy rövid, fejlesztő által megadott név megadásával, amely aztán a teljes szerkezeti formák helyett használható.

Részletes kialakítás

Így módosítjuk a using_alias_directive nyelvtanát:

using_alias_directive
-    : 'using' identifier '=' namespace_or_type_name ';'
+    : 'using' identifier '=' (namespace_name | type) ';'
    ;

A legfelső szintű hivatkozástípus nullbilitási széljegyzetei nem engedélyezettek.

Érdekes, hogy a §13.5.2 legtöbb előírásnyelvezete nem igényel változtatást. A legtöbb nyelv már "névtérre vagy típusra" hivatkozik, például:

A using_alias_directive olyan azonosítót vezet be, amely aliasként szolgál egy névtérhez vagy típushoz a közvetlenül környező összeállítási egység vagy a névtér törzsén belül található entitás számára.

Ez továbbra is igaz, csak az, hogy a nyelvhelyesség mostantól lehetővé teszi, hogy a "típus" tetszőleges típus legyen, nem pedig a korábban namespace_or_type_name által engedélyezett korlátozott készlet.

A frissítésre szoruló szakaszok a következők:

- The order in which using_alias_directives are written has no significance, and resolution of the namespace_or_type_name referenced by a using_alias_directive is not affected by the using_alias_directive itself or by other using_directives in the immediately containing compilation unit or namespace body. In other words, the namespace_or_type_name of a using_alias_directive is resolved as if the immediately containing compilation unit or namespace body had no using_directives. A using_alias_directive may however be affected by extern_alias_directives in the immediately containing compilation unit or namespace body. In the example
+ The order in which using_alias_directives are written has no significance, and resolution of the `(namespace_name | type)` referenced by a using_alias_directive is not affected by the using_alias_directive itself or by other using_directives in the immediately containing compilation unit or namespace body. In other words, the `(namespace_name | type)` of a using_alias_directive is resolved as if the immediately containing compilation unit or namespace body had no using_directives. A using_alias_directive may however be affected by extern_alias_directives in the immediately containing compilation unit or namespace body. In the example

- The namespace_name referenced by a using_namespace_directive is resolved in the same way as the namespace_or_type_name referenced by a using_alias_directive. Thus, using_namespace_directives in the same compilation unit or namespace body do not affect each other and can be written in any order.
+ The namespace_name referenced by a using_namespace_directive is resolved in the same way as the namespace_or_type_name referenced by a using_alias_directive. Thus, using_namespace_directives in the same compilation unit or namespace body do not affect each other and can be written in any order.

+ It is illegal for a using alias type to be a nullable reference type.

    1. `using X = string?;` is not legal.
    2. `using X = List<string?>;` is legal.  The alias is to `List<...>` which is itself not a nullable reference type itself, even though it contains one as a type argument.
    3. `using X = int?;` is legal.  This is a nullable *value* type, not a nullable *reference* type.

A mutatókat tartalmazó típusok aliasainak támogatása.

Egy új nem biztonságos környezet hozzáadásra kerül a using_alias_directive produkcióban egy opcionális "nem biztonságos" kulcsszóval.

using_alias_directive
+    : 'using' 'unsafe'? identifier '=' (namespace_name | type) ';'
    ;
    
using_static_directive
+    : 'using' 'static' 'unsafe'? type_name ';'
    ;

+ 'unsafe' can only be used with an using_alias_directive or using_static_directive, not a using_directive.
+ The 'unsafe' keyword present in a 'using_alias_directive' causes the entire textual extent of the 'type' portion (not the 'namespace_name' portion) to become an unsafe context. 
+ The 'unsafe' keyword present in a 'using_static_directive' causes the entire textual extent of the 'type_name' portion to become an unsafe context.