In che modo il sovraccarico è Compile Time e Overriding è Runtime?

Question

persone

Mi sono imbattuto in molti thread per la comprensione del polimorfismo (sia tempo di compilazione che tempo di esecuzione). Sono stato sorpreso di vedere alcuni link in cui i programmatori sostengono che Overloading è Runtime e Overriding è in fase di compilazione.

Quello che voglio sapere da qui è:

1. Runtime polimorfismo con un esempio TEMPO REALE e piccolo codice e quale scenario dovremmo usare.
2. Tempo di compilazione Polimorfismo con esempio REAL TIME e codice piccolo e quando utilizzare.

Perché ho letto molte definizioni teoriche, ma non sono soddisfatto nel comprenderlo.

Inoltre, ho dato un pensiero, che dove ho anche sentito, sovraccaricando dovrebbe essere il funzionamento, non perché, dire che ho un metodo che calcola l'area, in fase di esecuzione solo che decide quale metodo di overload di chiamare sulla base di parametri I PASS (Say se passo solo un parametro, dovrebbe sparare a Square, e se i parametri sono 2, dovrebbe sparare a Rectangle) .... Quindi non posso rivendicare il suo runtime? Come è il suo tempo? (La maggior parte si dice teoricamente, l'overloading è tempo di compilazione ma non danno nemmeno un esempio di REAL real time ... pochissimi ne rivendicano il tempo di esecuzione) ...

Inoltre, mi sembra che l'override sia tempo di compilazione perché, mentre scrivi codice e complie, assicurati di aver usato una parola chiave virtuale e anche di sovrascrivere quel metodo nella classe derivata che altrimenti ti darebbe un errore in fase di compilazione. Quindi sento il suo tempo di compilazione, allo stesso modo in cui ho visto in una discussione ..... Ma la maggior parte dei thread rivendica il suo runtime: D

Sono confuso :(Questa domanda è aggiuntiva alla mia domanda 1 e 2. Si prega di aiutare con un esempio in tempo reale .. come io sono già a conoscenza di definizioni teoriche .... :(

Grazie ....

Answer 1

In caso di sovraccarico, si utilizza il polimorfismo statico (in fase di compilazione) poiché il compilatore è a conoscenza esattamente del metodo che si sta chiamando. Ad esempio:

public static class test 
{ 
    static void Main(string[] args) 
    { 
     Foo(); 
     Foo("test"); 
    } 

    public static void Foo() 
    { 
     Console.WriteLine("No message supplied"); 
    } 

    public static void Foo(string message) 
    { 
     Console.WriteLine(message); 
    } 
} 

In questo caso, il compilatore sa esattamente quale metodo Foo() chiediamo, in base al numero/tipo di parametri.

Override è un esempio di polimorfismo dinamico (runtime). Ciò è dovuto al fatto che il compilatore non sa necessariamente quale tipo di oggetto viene passato in fase di compilazione. Supponiamo di avere le seguenti classi in una libreria:

public static class MessagePrinter 
{ 
    public static void PrintMessage(IMessage message) 
    { 
     Console.WriteLine(message.GetMessage()); 
    } 
} 

public interface IMessage 
{ 
    public string GetMessage(); 
} 

public class XMLMessage : IMessage 
{ 
    public string GetMessage() 
    { 
     return "This is an XML Message"; 
    } 
} 

public class SOAPMessage : IMessage 
{ 
    public string GetMessage() 
    { 
     return "This is a SOAP Message"; 
    } 
} 

In fase di compilazione, non so se il chiamante di quella funzione passa in un XMLMessage, un SOAPMessage, o forse un altro tipo di IMessage definito altrove. Quando il PrintMessage() è chiamata, determina quale versione di GetMessage() da utilizzare in fase di esecuzione, in base al tipo di IMessage che viene passato.

Answer 2

Leggi: Polymorphism (C# Programming Guide)

risposta simile: Compile Time and run time Polymorphism

Bene, ci sono due tipi di Il polimorfismo come indicato di seguito:

• Statico polimorfismo (l'associazione anticipata)
• dinamica polimorfismo (tardiva)

Statico polimorfismo (associazione anticipata):

statico polimorfismo è anche sapere come polimorfismo di Early Binding e Compile time. Il sovraccarico del metodo e il sovraccarico dell'operatore sono esempi degli stessi.

È noto come Early Binding poiché il compilatore è a conoscenza delle funzioni con lo stesso nome e anche la funzione di overload è chiamata in fase di compilazione.

Ad esempio:

public class Test 
{ 
    public Test() 
    { 

    } 

    public int add(int no1, int no2) 
    { 

    } 

    public int add(int no1, int no2, int no3) 

    { 

    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     Test tst = new Test(); 
     int sum = tst.add(10, 20); 

     // here in above statement compiler is aware at compile time that need to call function add(int no1, int no2), hence it is called early binding and it is fixed so called static binding. 
    } 
} 

dinamico Polimorfismo (associazione tardiva):

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

Come nel codice precedente, come qualsiasi altra chiamata ad un metodo virtuale, sarà compilato un callvirt IL istruzione. Ciò significa che il metodo effettivo che viene chiamato è determinato in fase di esecuzione (a meno che il JIT possa ottimizzare alcuni casi speciali), ma il compilatore ha verificato che il metodo esiste, ha scelto il sovraccarico più appropriato (se presente) e ha la garanzia che il puntatore di funzione esisterà in una posizione ben definita nel vtable del tipo (anche se si tratta di un dettaglio di implementazione). Il processo di risoluzione della chiamata virtuale è estremamente veloce (devi solo dereferenziare alcuni indicatori), quindi non fa molta differenza.

Answer 3

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

questo polimorfismo dinamico, poiché è decisa runtime quale versione di MakeSound sarà chiamata sia del genitore che del figlio, poiché un bambino non può sovrascrivere la funzione genitore o può sovrascriverla ma tutto ciò viene deciso in fase di runtime, a quale versione viene chiamata ....