Imagine un tipo en el nivel del espacio de nombres raíz (podría estar en el espacio global predeterminado o podría ser un extern alias ).

Parece que no se puede hacer referencia a este tipo a través de nameof() , cuando se usa el prefijo de alias. Funciona bien con typeof y mediante el using alias (aunque nameof en un alias de using produce el nombre del alias, no el nombre del tipo). El compilador objeta CS8083, "Un nombre calificado con alias no es una expresión".

Pero: ¿hay alguna razón para esto? ¿Esto está tratando de prevenir algún escenario de problema oscuro? o cumplir con algunos minutos de especificación? ¿O es quizás un error del compilador? También me complace señalar que, por lo general , no deberíamos declarar tipos en la raíz del espacio de nombres: CA1050 tiene mucha razón al respecto; pero ese no es el punto aquí :)

A continuación se muestra un ejemplo completo; tenga en cuenta que en este ejemplo se usan dos proyectos para using la verificación de alias, pero para simplificar, todo lo que involucre a C puede ignorarse para una investigación simple.

 extern alias foo; using System; using X = global::A; using Y = global::FunWithNamespaces.B; using Z = foo::C; public class A { } namespace FunWithNamespaces { public class B { } public class Program { static void Main() { // oddness is on the lines marked ## CS8083 // relative-qualified using typeof Console.WriteLine(typeof(X).Name); // A, expected Console.WriteLine(typeof(Y).Name); // B, expected Console.WriteLine(typeof(Z).Name); // C, expected Console.WriteLine(typeof(A).Name); // A Console.WriteLine(typeof(B).Name); // B // note: can't talk about C without using an alias qualifier or a using-alias Console.WriteLine(typeof(Console).Name); // Console // relative-qualified things using nameof Console.WriteLine(nameof(X)); // X; I'm on the fence about X vs A, but... whatever Console.WriteLine(nameof(Y)); // Y; I'm on the fence about Y vs B, but... whatever Console.WriteLine(nameof(Z)); // Z; I'm on the fence about Z vs C, but... whatever Console.WriteLine(nameof(A)); // A Console.WriteLine(nameof(B)); // B // note: can't talk about C without using an alias qualifier or a using-alias Console.WriteLine(nameof(Console)); // Console // alias-qualified things using typeof Console.WriteLine(typeof(global::A).Name); // A Console.WriteLine(typeof(global::FunWithNamespaces.B).Name); // B Console.WriteLine(typeof(foo::C).Name); // C Console.WriteLine(typeof(global::System.Console).Name); // Console // alias-qualified things using nameof // ??? Console.WriteLine(nameof(global::A)); // ## CS8083 An alias-qualified name is not an expression Console.WriteLine(nameof(global::FunWithNamespaces.B)); // B // ??? Console.WriteLine(nameof(foo::C)); // ## CS8083 An alias-qualified name is not an expression Console.WriteLine(nameof(global::System.Console)); // Console } } }

donde C se define en un ensamblado separado y se hace referencia con alias especificados como foo , y es simplemente:

 public class C { }

Editar: en términos de especificación, esto se reduce a https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/language-specification/expressions#nameof-expressions , donde nameof_expression debe ser un simple_name (que no lo es) o un named_entity_target '.' identifier type_argument_list? - entonces: para todos los casos que no son un nombre simple, debe haber un .something - pero supongo que la pregunta subyacente aquí es ¿por qué debe haber un .something , frente a alguna otra construcción que permita global::Foo ? Por ejemplo:

 nameof_expression : 'nameof' '(' named_entity ')' ; named_entity : simple_name | named_entity_target '.' identifier type_argument_list? | qualified_alias_member type_argument_list? ; named_entity_target : 'this' | 'base' | named_entity | predefined_type | qualified_alias_member ;