Polymorphisme en C# : liaison statique vs dynamique expliquée

Le polymorphisme signifie "plusieurs formes". En POO, il s'exprime comme "une interface, multiples fonctions".

Deux types :

• Polymorphisme statique : résolution à la compilation (early binding)
• Polymorphisme dynamique : résolution à l'exécution (late binding)

Polymorphisme statique

Deux techniques :

1. Surcharge de fonctions (Function Overloading)
2. Surcharge d'opérateurs (Operator Overloading)

Surcharge de fonctions

Même nom, signatures différentes (types/nombre paramètres). Pas surcharge sur type retour seul.

using System;

namespace ApplicationPolymorphisme
{
    class AffichageDonnees
    {
        public void Afficher(int i)
        {
            Console.WriteLine("Entier : {0}", i);
        }
        
        public void Afficher(double f)
        {
            Console.WriteLine("Flottant : {0}", f);
        }
        
        public void Afficher(string s)
        {
            Console.WriteLine("Chaîne : {0}", s);
        }
        
        static void Main(string[] args)
        {
            AffichageDonnees a = new AffichageDonnees();
            a.Afficher(5);
            a.Afficher(500.263);
            a.Afficher("Hello C#");
            Console.ReadKey();
        }
    }
}

Résultat :

Entier : 5
Flottant : 500.263
Chaîne : Hello C#

Polymorphisme dynamique

Implémenté via classes abstraites et méthodes virtuelles.

Classes abstraites

• Ne peuvent pas être instanciées
• Contiennent des méthodes abstraites (sans implémentation)
• Ne peuvent pas être sealed

Exemple classe abstraite

using System;

namespace ApplicationPolymorphisme
{
    abstract class Forme
    {
        public abstract int Aire();
    }
    
    class Rectangle : Forme
    {
        private int longueur, largeur;
        
        public Rectangle(int a = 0, int b = 0)
        {
            longueur = a; largeur = b;
        }
        
        public override int Aire()
        {
            Console.WriteLine("Aire Rectangle :");
            return largeur * longueur;
        }
    }
    
    class TestRectangle
    {
        static void Main(string[] args)
        {
            Rectangle r = new Rectangle(10, 7);
            double a = r.Aire();
            Console.WriteLine("Aire : {0}", a);
            Console.ReadKey();
        }
    }
}

Méthodes virtuelles

Méthode définie dans classe de base, redéfinie (override) dans classes dérivées. Appel résolu à l'exécution.

using System;

namespace ApplicationPolymorphisme
{
    class Forme
    {
        protected int largeur, hauteur;
        public Forme(int a = 0, int b = 0) { largeur = a; hauteur = b; }
        
        public virtual int Aire()
        {
            Console.WriteLine("Aire classe parente :");
            return 0;
        }
    }
    
    class Rectangle : Forme
    {
        public Rectangle(int a = 0, int b = 0) : base(a, b) { }
        public override int Aire()
        {
            Console.WriteLine("Aire Rectangle :");
            return largeur * hauteur;
        }
    }
    
    class Triangle : Forme
    {
        public Triangle(int a = 0, int b = 0) : base(a, b) { }
        public override int Aire()
        {
            Console.WriteLine("Aire Triangle :");
            return largeur * hauteur / 2;
        }
    }
    
    class Appelant
    {
        public void AppelerAire(Forme f)
        {
            int a = f.Aire();
            Console.WriteLine("Aire : {0}", a);
        }
    }
    
    class Test
    {
        static void Main(string[] args)
        {
            Appelant a = new Appelant();
            Rectangle r = new Rectangle(10, 7);
            Triangle t = new Triangle(10, 5);
            a.AppelerAire(r);
            a.AppelerAire(t);
            Console.ReadKey();
        }
    }
}

Résultat :

Aire Rectangle : Aire : 70
Aire Triangle : Aire : 25