Surcharge de Méthode

La surcharge de méthode en C# vous permet de définir plusieurs méthodes avec le même nom dans une classe, chacune différant par leurs types de paramètres, leur nombre de paramètres, ou les deux, offrant ainsi une manière plus propre et plus adaptable de gérer divers scénarios d'entrée.

Par exemple, nous pouvons avoir deux méthodes avec le même nom mais un nombre différent de paramètres :

index


              12345678910111213141516171819
            
using System;
class ConsoleApp
{
    static int sum(int a, int b)
    {
        return a + b;
    }

    static int sum(int a, int b, int c)
    {
        return a + b + c;
    }

    static void Main()
    {
        Console.WriteLine(sum(5, 7));
        Console.WriteLine(sum(5, 7, 9));
    }
}

Dans le code ci-dessus, la méthode sum a été surchargée pour avoir deux variations de paramètres. Une méthode peut également avoir différents types de retour pour différentes variations d'elle-même, cependant, il est important qu'elle n'ait aucune ambiguïté, sinon le compilateur affichera une erreur car la principale façon pour un compilateur de distinguer entre deux méthodes du même nom est leur liste de paramètres.

Par exemple :

index


              12345678910
            
static int sum(int a, int b)
{
    return a + b;
}

// This is wrong and will show an error
static long sum(int a, int b)
{
    return a + b;
}

Le code ci-dessus est incorrect car les paramètres sont exactement les mêmes que ceux de la méthode originale tandis que le type de retour est différent, ce qui n'est pas autorisé car cela rend impossible pour le compilateur (ou même pour les humains) de choisir lequel exécuter lorsque la méthode est appelée :

index


              123
            
sum(1, 3); 
// Should it execute `int sum(int a, int b)` or `long sum(int a, int b)` ? 
// It is impossible to reach a good answer for the compiler in this case so it shows an error

C'est pourquoi, lors de la surcharge d'une méthode, une méthode qui a un type de retour différent devrait également avoir un ensemble de paramètres différent pour la rendre identifiable et éliminer l'ambiguïté. Ce qui suit est également incorrect :

index


              12345678910
            
static int sum(int a, int b)
{
    return a + b;
}

// This is wrong and will show an error
static long sum(int first, int second)
{
    return first + second;
}

C'est parce que les noms des paramètres n'ont pas d'importance, mais leurs types oui. Les cas de surcharge suivants sont valides :

index


              1234567891011121314151617181920212223242526
            
using System;
class ConsoleApp
{
    static int sum(int a, int b)
    {
        return a + b;
    }

    static long sum(long a, long b)
    {
        return a + b;
    }

    static string sum(int a, long b, float c)
    {
        return Convert.ToString(a + b + c);
    }

    static void Main()
    {
        Console.WriteLine(sum(5, 7)); // Calls 'int sum()'
        Console.WriteLine(sum(500000000000, 700000000000)); // Calls 'long sum()'
        Console.WriteLine(sum(5, 7, 9)); // Calls 'string sum()'
    }
}

1. Comment le compilateur différencie-t-il les méthodes surchargées ?

2. Lequel des exemples suivants est un exemple valide de surcharge de méthode ?

Tout était clair ?

Merci pour vos commentaires !

Section 4. Chapitre 7