Почему метод компилятора не может переопределить?

Question

В следующих C# фрагмент

public class Animal 
{ 
    public virtual void MakeSound() 
    { 
     Console.WriteLine("Animal sound"); 
    } 
} 

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

class Program 
{ 
    static void Main(string[] args) 
    { 
     Animal an = new Dog(); 
     an.MakeSound();   
     Console.ReadLine(); 
    } 
} 

метод, который можно назвать определяется во время выполнения. Почему точно не может компилятор выяснить, какой метод вызывать?

Почему компилятор не видит, что an относится к объекту Dog, а затем выбрать метод из этого класса?

И как среда выполнения определяет, какой метод будет вызываться?

Answer 1

Вы сказали компилятору, что переменная имеет тип Animal. Он выглядит только на объявлениях, в то время как вы ожидаете, что он выполнит ваш код, чтобы понять, что вы имеете в виду. Это не так, как это работает.

Answer 2

Это звучит очень много, как вопрос об экзамене/домашнем задании. Но позвольте мне ответить на ваш вопрос другим вопросом. Рассмотрим следующий код:

static void Main(string[] args) 
{ 
    var random = new Random(); 
    Animal an = null; 
    if (random.NextDouble() < 0.5) { 
     an = new Dog(); 
    } else { 
     an = new Cat(); 
    } 

    an.MakeSound();   
    Console.ReadLine(); 
} 

Как компилятор должен знать, во время компиляции, какой метод вызвать? Он не может, только во время работы известен конкретный тип.

Answer 3

Рассмотрим следующий код:

class Program 
{ 
    static void Main(string[] args) 
    { 
     Animal dog = new Dog(); 
     MakeSoundAbstract(dog); 

     Animal an = new Animal(); 
     MakeSoundAbstract(an); 

     Console.ReadLine(); 
    } 

    static void MakeSoundAbstract(Animal animal) 
    { 
     animal.MakeSound(); 
    } 
} 

Если компилятор будет определять виртуальные вызовы во время компиляции не во время выполнения, то MakeSoundAbstract метод всегда будет выполнять MakeSound метод class Animal таким образом мы теряем здесь власть abstraction.

Answer 4

Рассмотрим эти изменения в код:

public class Animal 
{ 
    public virtual void MakeSound() 
    { 
    Console.WriteLine("Animal sound"); 
    } 
} 

public class Dog : Animal 
{ 
    public override void MakeSound() 
    { 
    Console.WriteLine("Woof!"); 
    } 
} 

public class Cat : Animal 
{ 
    public override void MakeSound() 
    { 
    Console.WriteLine("Purrrrrrrrrrrrrr"); 
    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
    Animal an = GetAnimal(DateTime.Now); 
    an.MakeSound();   
    Console.ReadLine(); 
    } 

    private Animal GetAnimal(DateTime dateTime) 
    { 
    if (dateTime.DayOfWeek == DayOfWeek.Monday) 
    { 
     return new Dog(); 
    } 
    else 
    { 
     return new Cat(); 
    } 
    } 
} 

Теперь это невозможно знать, какой тип животного, чтобы создать во время компиляции, так как это зависит от дня недели, когда код на самом деле запустить. По понедельникам вы получите собаку, но в любой другой момент вы получите кота. Это определяющее преимущество полиморфизма - типы не запекаются компилятором, а производятся на лету, когда выполняется код. Полиморфизм позволяет работать с этими производными типами, даже если вы точно не знаете, что они будут, когда вы пишете свой код (но вы знаете, что это все виды животных).