web-dev-qa-db-fra.com

Comment surcharger le temps de compilation et surcharger le runtime?

Gens

Je suis tombé sur de nombreuses discussions pour comprendre le polymorphisme (le temps de compilation et le temps d'exécution). J'ai été surpris de voir des liens vers lesquels les programmeurs prétendent que la surcharge est à l'exécution et que la priorité est à la compilation.

Ce que je veux savoir d'ici, c'est:

  1. Polymorphisme d'exécution avec un exemple REAL TIME et un petit code et quel scénario nous devrions utiliser.
  2. Compile time Polymorphism avec exemple REAL TIME et petit code et quand utiliser.

Parce que j'ai lu beaucoup de définitions théoriques, mais je ne suis pas satisfait de comprendre cela.

De plus, j’ai pensé que, là où j’ai aussi ressenti, la surcharge devrait être une exécution, car parce que, disons, j’ai une méthode qui calcule Area, elle décide uniquement quelle méthode surchargée appeler en fonction des paramètres que je passe (Dites si je passe seulement un paramètre, il devrait déclencher Square, et si les paramètres sont 2, il devrait déclencher Rectangle) ... Donc, est-ce que je ne peux pas réclamer son temps d'exécution? Comment son temps de se conformer? (La plupart disent théoriquement que la surcharge est un temps de compilation, mais ils ne donnent même pas un exemple de temps REEL correct ... très peu de gens réclament son temps d'exécution) ....

De plus, j’ai le sentiment que le temps de compilation est primordial, car pendant que vous écrivez du code et que vous vous conformez, vous vous assurez d’avoir utilisé un mot clé virtuel et que vous surchargez également cette méthode dans une classe dérivée qui, sinon, vous donnerait une erreur de temps de compilation. Je ressens donc son temps de compilation, de la même manière que dans un thread ..... Mais la plupart des threads réclament son exécution: D

Je suis confus :( Cette question est complémentaire à mes questions 1 et 2. S'il vous plaît aider avec un exemple en temps réel .. comme je suis déjà au courant des définitions théoriques .... :(

Je vous remercie....

c#.netoop
17
Learner

En cas de surcharge, vous utilisez un polymorphisme statique (au moment de la compilation) car le compilateur sait exactement quelle méthode vous appelez. Par exemple:

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

Dans ce cas, le compilateur sait exactement quelle méthode Foo () nous appelons, en fonction du nombre/du type de paramètres.

La substitution est un exemple de polymorphisme dynamique (à l'exécution). Cela est dû au fait que le compilateur ne sait pas nécessairement quel type d'objet est transmis lors de la compilation. Supposons que vous ayez les classes suivantes dans une bibliothèque:

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

Au moment de la compilation, vous ne savez pas si l'appelant de cette fonction transmet un XMLMessage, un SOAPMessage ou éventuellement un autre type d'iMessage défini ailleurs. Lorsque la fonction PrintMessage () est appelée, elle détermine la version de GetMessage () à utiliser au moment de l’exécution, en fonction du type d’iMessage transmis.

16
Jon Senchyna

Lire: Polymorphisme (Guide de programmation C #)

Réponse similaire: Compile Time and run time Polymorphism

Eh bien, il existe deux types de polymorphisme, comme indiqué ci-dessous: 

  • Polymorphisme statique (liaison précoce) 
  • Polymorphisme dynamique (liaison tardive)

Polymorphisme statique (liaison précoce):

Le polymorphisme statique est également connu sous le nom de polymorphisme au début de la compilation et de la compilation. Les méthodes Overloading et Operator Overloading sont des exemples identiques.

Il est connu sous le nom de Early Binding, car le compilateur connaît les fonctions du même nom et la fonction surchargée à appeler est connue au moment de la compilation.

Par exemple:

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.
    }
}

Polymorphisme dynamique (liaison tardive): 

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

Comme dans le code ci-dessus, comme tout autre appel à une méthode virtuelle, sera compilé en une instruction callvirt IL. Cela signifie que la méthode qui est appelée est déterminée au moment de l'exécution (sauf si le JIT peut optimiser certains cas particuliers), mais que le compilateur a vérifié que la méthode existe, il a choisi la surcharge (le cas échéant) la plus appropriée et a la garantie que le pointeur de fonction existera à un emplacement bien défini dans la vtable du type (même s'il s'agit d'un détail d'implémentation). Le processus de résolution de l'appel virtuel est extrêmement rapide (il suffit de déréférencer quelques pointeurs), de sorte que cela ne fait pas une grande différence.

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

c'est un polymorphisme dynamique, car il est décidé au moment de l'exécution quelle version de MakeSound sera appelée du parent ou de l'enfant, puisqu'un enfant ne peut pas écraser la fonction parent ou peut l'écraser, mais tout cela est décidé à l'exécution, quelle version est appelé ....

0
Usama Qureshi