Questa è Sparta, o no?

Quella che segue è una domanda dell'intervista. Ho trovato una soluzione, ma non sono sicuro del motivo per cui funziona.

Domanda:

Senza modificare la Spartaclasse, scrivi del codice che MakeItReturnFalseritorni false.

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

La mia soluzione: (SPOILER)

public class Place
{
public interface Sparta { }
}

Ma perché Spartain si MakeItReturnFalse()riferisce a {namespace}.Place.Spartainvece di {namespace}.Sparta?

Ma perché Spartain si MakeItReturnFalse()riferisce a {namespace}.Place.Spartainvece di {namespace}.Sparta?

Fondamentalmente, perché è quello che dicono le regole di ricerca del nome. Nella specifica C # 5, le regole di denominazione rilevanti sono nella sezione 3.8 ("Spazio dei nomi e nomi dei tipi").

La prima coppia di punti - troncati e annotati - leggi:

• Se il nome dello spazio dei nomi o del tipo è della forma Io della forma I<A1, ..., AK> [quindi K = 0 nel nostro caso] :
  • Se K è zero e il nome dello spazio dei nomi o del tipo viene visualizzato all'interno di una dichiarazione di metodo generico [no, nessun metodo generico]
  • Altrimenti, se lo spazio dei nomi o il nome del tipo appare all'interno di una dichiarazione di tipo, allora per ogni istanza digitare T (§10.3.1), iniziando con il tipo di istanza di quella dichiarazione di tipo e continuando con il tipo di istanza di ciascuna classe che lo racchiude o dichiarazione struct (se presente):
    • Se Kè zero e la dichiarazione di Tinclude un parametro di tipo con nome I, lo spazio dei nomi o il nome del tipo si riferisce a quel parametro di tipo. [No]
    • Altrimenti, se lo spazio dei nomi o il nome del tipo appare nel corpo della dichiarazione del tipo e T o uno qualsiasi dei suoi tipi di base contiene un tipo accessibile annidato con parametri di nome Ie Ktipo, lo spazio dei nomi o il nome del tipo si riferisce a quello tipo costruito con gli argomenti di tipo forniti. [Bingo!]
• Se i passaggi precedenti non hanno avuto esito positivo, per ogni spazio dei nomi N, a partire dallo spazio dei nomi in cui si trova lo spazio dei nomi o il nome del tipo, continuando con ogni spazio dei nomi racchiuso (se presente) e terminando con lo spazio dei nomi globale, vengono valutati i seguenti passaggi finché non si trova un'entità:
  • Se Kè zero ed Iè il nome di uno spazio dei nomi in N, allora ... [Sì, sarebbe riuscito]

Quindi il punto finale dell'elenco è ciò che rileva la Sparta classe se il primo punto non trova nulla ... ma quando la classe base Placedefinisce un'interfaccia Sparta, viene trovata prima di considerare la Spartaclasse.

Nota che se rendi il tipo annidato Place.Spartauna classe piuttosto che un'interfaccia, viene comunque compilato e restituito false, ma il compilatore emette un avviso perché sa che un'istanza di Spartanon sarà mai un'istanza della classe Place.Sparta. Allo stesso modo, se mantieni Place.Spartaun'interfaccia ma crei la Spartaclasse sealed, riceverai un avviso perché nessuna Spartaistanza potrebbe mai implementare l'interfaccia.

Quando si risolve un nome nel suo valore, la "vicinanza" della definizione viene utilizzata per risolvere le ambiguità. Qualunque sia la definizione "più vicina" è quella scelta.

L'interfaccia Spartaè definita all'interno di una classe base. La classe Spartaè definita nello spazio dei nomi contenitore. Le cose definite all'interno di una classe base sono "più vicine" di quelle definite nello stesso spazio dei nomi.

Bella domanda! Vorrei aggiungere una spiegazione leggermente più lunga per coloro che non fanno C # quotidianamente ... perché la domanda è un buon promemoria dei problemi di risoluzione dei nomi in generale.

Prendi il codice originale, leggermente modificato nei seguenti modi:

• Stampiamo i nomi dei tipi invece di confrontarli come nell'espressione originale (es return this is Sparta ).
• Definiamo l'interfaccia Athena nella Placesuperclasse per illustrare la risoluzione del nome dell'interfaccia.
• Stampiamo anche il nome del tipo di thiscome è associato nella Spartaclasse, solo per rendere tutto molto chiaro.

Il codice ha questo aspetto:

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));
    }
}

Creiamo ora un Spartaoggetto e chiamiamo i tre metodi.

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

L'output che otteniamo è:

Sparta
Athena
Place+Athena

Tuttavia, se modifichiamo la classe Place e definiamo l'interfaccia Sparta:

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

quindi è questa Sparta- l'interfaccia - che sarà disponibile per prima per il meccanismo di ricerca del nome e l'output del nostro codice cambierà in:

Sparta
Place+Sparta
Place+Athena

Quindi abbiamo effettivamente incasinato il confronto dei tipi nella MakeItReturnFalsedefinizione della funzione semplicemente definendo l'interfaccia di Sparta nella superclasse, che si trova prima dalla risoluzione del nome.

Ma perché C # ha scelto di dare la priorità alle interfacce definite nella superclasse nella risoluzione dei nomi? @ JonSkeet lo sa! E se leggi la sua risposta otterrai i dettagli del protocollo di risoluzione dei nomi in C #.