Este é Esparta, ou é?

O seguinte é uma pergunta da entrevista. Eu vim com uma solução, mas não sei por que isso funciona.

Questão:

Sem modificar a Spartaclasse, escreva algum código que MakeItReturnFalseretorne false.

public class Sparta : Place
{
    public bool MakeItReturnFalse()
    {
        return this is Sparta;
    }
}

Minha solução: (SPOILER)

public class Place
{
public interface Sparta { }
}

Mas por que Spartaem MakeItReturnFalse()referem-se {namespace}.Place.Sparta, em vez de {namespace}.Sparta?

Mas por que Spartaem MakeItReturnFalse()referem-se {namespace}.Place.Sparta, em vez de {namespace}.Sparta?

Basicamente, porque é o que dizem as regras de pesquisa de nome. Na especificação C # 5, as regras de nomenclatura relevantes estão na seção 3.8 ("Namespace e nomes de tipo").

O primeiro par de marcadores - truncados e anotados - dizia:

• Se o namespace-ou-type-name for da forma Iou da forma I<A1, ..., AK> [então K = 0 no nosso caso] :
  • Se K for zero e o namespace-ou-type-name aparecer em uma declaração genérica de método [não, nenhum método genérico]
  • Caso contrário, se o namespace ou nome do tipo aparecer em uma declaração de tipo, para cada instância digite T (§10.3.1), começando com o tipo de instância dessa declaração de tipo e continuando com o tipo de instância de cada classe envolvente ou declaração struct (se houver):
    • Se Kfor zero e a declaração de Tincluir um parâmetro de tipo com nome I, o namespace-ou-type-name se refere a esse parâmetro de tipo. [Não]
    • Caso contrário, se o namespace-ou-type-name aparecer no corpo da declaração de tipo, T ou se algum de seus tipos de base contiver um tipo acessível aninhado com parâmetros de nome Ie Ktipo, o namespace-ou-type-name se refere a esse tipo construído com os argumentos de tipo fornecidos. [Bingo!]
• Se as etapas anteriores não tiveram êxito, para cada espaço de nome N , começando com o espaço para nome no qual o espaço para nome ou nome do tipo ocorre, continuando com cada espaço para nome (se houver) e terminando com o espaço para nome global, as etapas a seguir serão avaliadas até que uma entidade esteja localizada:
  • Se Kfor zero e Ifor o nome de um espaço para nome N, então ... [Sim, isso seria bem-sucedido]

Portanto, esse ponto final é o que seleciona a Sparta classe se o primeiro marcador não encontrar nada ... mas quando a classe base Placedefine uma interface Sparta, ela é encontrada antes de considerarmos a Spartaclasse.

Observe que, se você tornar o tipo aninhado Place.Spartauma classe em vez de uma interface, ele ainda compila e retorna false- mas o compilador emite um aviso porque sabe que uma instância de Spartanunca será uma instância da classe Place.Sparta. Da mesma forma, se você mantiver Place.Spartauma interface, mas fizer a Spartaclasse sealed, receberá um aviso porque nenhuma Spartainstância jamais poderia implementar a interface.

Ao resolver um nome com seu valor, a "proximidade" da definição é usada para resolver ambiguidades. Qualquer definição que seja "mais próxima" é a que é escolhida.

A interface Spartaé definida dentro de uma classe base. A classe Spartaé definida no espaço para nome que contém. As coisas definidas em uma classe base são "mais próximas" do que as definidas no mesmo espaço para nome.

Bela pergunta! Gostaria de adicionar uma explicação um pouco mais longa para quem não faz C # diariamente ... porque a pergunta é um bom lembrete dos problemas de resolução de nomes em geral.

Pegue o código original, ligeiramente modificado das seguintes maneiras:

• Vamos imprimir os nomes dos tipos em vez de compará-los como na expressão original (ie return this is Sparta).
• Vamos definir a interface Athenana Placesuperclasse para ilustrar a resolução do nome da interface.
• Vamos também imprimir o nome do tipo thiscomo está vinculado na Spartaclasse, apenas para deixar tudo muito claro.

O código fica assim:

public class Place {
    public interface Athena { }
}

public class Sparta : Place
{
    public void printTypeOfThis()
    {
        Console.WriteLine (this.GetType().Name);
    }

    public void printTypeOfSparta()
    {
        Console.WriteLine (typeof(Sparta));
    }

    public void printTypeOfAthena()
    {
        Console.WriteLine (typeof(Athena));
    }
}

Agora criamos um Spartaobjeto e chamamos os três métodos.

public static void Main(string[] args)
    {
        Sparta s = new Sparta();
        s.printTypeOfThis();
        s.printTypeOfSparta();
        s.printTypeOfAthena();
    }
}

A saída que obtemos é:

Sparta
Athena
Place+Athena

No entanto, se modificarmos a classe Place e definirmos a interface Sparta:

   public class Place {
        public interface Athena { }
        public interface Sparta { } 
    }

então é isso Sparta- a interface - que estará disponível primeiro para o mecanismo de pesquisa de nome e a saída do nosso código será alterada para:

Sparta
Place+Sparta
Place+Athena

Então, nós estragamos efetivamente a comparação de tipos no MakeItReturnFalse definição de função, apenas definindo a interface Sparta na superclasse, que é encontrada primeiro pela resolução de nomes.

Mas por que o C # optou por priorizar as interfaces definidas na superclasse na resolução de nomes? @JonSkeet sabe! E se você ler a resposta dele, obterá os detalhes do protocolo de resolução de nomes em C #.