Perché l'override di un metodo di verifica solo dopo che ho implementare un'interfaccia?

Question

Ho letto il libro di lavoro in modo efficace con il codice legacy e ho giocato in giro con il concetto di override difficile da metodi di prova nel test di unità attraverso la creazione di un falso. Ho messo insieme un esempio di quello che pensavo avrebbe funzionato ed è finito per comportarsi in modo diverso di quanto mi ero aspettato. Penso di aver appena scoperto un buco nella mia comprensione di come l'ereditarietà e il metodo sovraccarico opere in C # e mi chiedevo se qualcuno potesse aiutarmi a capire cosa sta succedendo qui.

Ho la seguente interfaccia:

public interface IAnimal
{
    void MakeSound();
    void Move();
}

Ho quindi creare un'implementazione dell'interfaccia animali come segue:

public class Dog : IAnimal
{

public void MakeSound()
{
    Console.WriteLine("Woof");
}

public void Move()
{
    Console.WriteLine("Moved");
}

}

Quando uso questa classe come segue:

IAnimal myanimal = new Dog();
myanimal.MakeSound();
myanimal.Move();

ottengo il seguente output: Trama Spostato

Ora, consente di far finta che sto bisogno di test di unità della classe Dog, ma uno dei metodi, MakeSound (), ha bisogno di trovare un limite, perché sta facendo la classe difficile da testare per qualche ragione.

creo un cane finto estendendo la classe Cane e la creazione di un metodo per MakeSound

public class FakeDog : Dog
{
    public void MakeSound()
    {
         Console.WriteLine("Bark");
    }
}

Quando uso questa classe come segue:

IAnimal myanimal = new FakeDog();
myanimal.MakeSound();
myanimal.Move();

ottengo il seguente output: Trama Spostato

Mi aspettavo che sia stato: Abbaiare Spostato

Tuttavia, se poi ho la classe FakeDog implementare l'interfaccia animali e usarlo:

public class FakeDog : Dog, IAnimal
{
    public void MakeSound()
    {
         Console.WriteLine("Bark");
    }
}

ottengo il seguente output: Abbaiare Spostato

Sono solo voglia di capire il motivo per cui questo ora l'override del metodo, come mi aspettavo, quando mi era stato appena esteso la classe Dog. Qualcuno mi può impostare dritto su questa?

Answer 1

Nel primo caso si sta creando un nuovo metodo che pelli l'implementazione originale di IAnimal.MakeSound. Avresti dovuto vedere un avvertimento che suggerisce che si utilizza la parola chiave new per rendere questo esplicito.

Nel secondo caso si è ri-attuazione IAnimal. L'implementazione di un'interfaccia non richiede la parola override (anche se sarebbe stato bello se i progettisti di linguaggi had richiesto che).

Per evitare la ri-implementando l'interfaccia, si potrebbe fare MakeSound virtuale in Dog, e quindi sovrascrivere esplicitamente in FakeDog. A quel punto c'è solo una possibile risoluzione coinvolti, e tutto ciò che è più semplice da capire. Cerco di evitare reimplementazione e il metodo di nascondersi quando possibile.

Answer 2

(Ci scusiamo per rispondere con una domanda, ma si potrebbe davvero trovare questo esperimento informativo) Cosa succede quando si implementa cane come segue:

public class Dog : IAnimal
{

public virtual void MakeSound()
{
    Console.WriteLine("Woof");
}

//...

Si noti la "virtuale"

Answer 3

È necessario dichiarare il metodo MakeSound come virtual nella classe Dog e di override nella classe FakeDog:

public class Dog : IAnimal
{
    public virtual void MakeSound()
    {
        Console.WriteLine("Woof");
    }

    public virtual void Move()
    {
        Console.WriteLine("Moved");
    }
}

public class FakeDog : Dog
{
    public override void MakeSound()
    {
        Console.WriteLine("Bark");
    }
}