Présentation de la surcharge en C #

Dans Overloading in C #, Polymorphism est un concept de programmation orientée objet qui définit la capacité d'un objet, d'une variable ou d'une méthode à assumer plusieurs formes pendant la compilation / exécution. Les facteurs en temps réel tels que les données, les paramètres, le retour d'un objet, etc. déterminent la forme que prendra l'objet / la méthode / la variable. Cela permet au programmeur de coder de manière plus générique plutôt que spécifique. Par exemple, vous mangez des fruits. La façon dont vous mangez des fruits dépend des fruits qui vous sont fournis en temps réel. Vous mangez une pomme tout de suite tandis que vous épluchez une banane avant de manger. Facile.

Qu'est-ce que la surcharge de méthode en C #?

La surcharge de méthode est l'implémentation au moment de la compilation du concept de polymorphisme. Les développeurs peuvent définir des méthodes similaires sous le même nom, différant par le nombre d'arguments, l'ordre des arguments ou le type d'arguments. Dans l'exemple des fruits, vous n'avez pas besoin de définir des méthodes distinctes pour chaque fruit (eatApple, eat the banana, etc.). Vous pouvez utiliser le même nom pour manger des fruits et lui passer différents paramètres. Le compilateur appelle automatiquement la méthode appropriée.

Prenons maintenant la perspective de C #. Dans les termes les plus simples, la surcharge de méthode en C # est lorsque vous avez deux méthodes ou plus avec le même nom mais des signatures différentes. Cela peut être réalisé de différentes manières:

  • Le nombre différent de paramètres.
  • Différents types de paramètres.
  • Ordre des paramètres différent.
  • Paramètres facultatifs.
  • Arguments nommés.

Comment fonctionne la surcharge de méthode en C #?

Alors, comment appelle-t-on la méthode appropriée en fonction des arguments / paramètres? Eh bien, le compilateur vérifie chaque définition de méthode lors de la compilation et lie les appels de méthode aux définitions respectives. Dans le cas où il existe deux méthodes portant le même nom, le compilateur vérifie ensuite la signature des méthodes et lie la définition appropriée à l'appel. Même si les signatures ne peuvent pas résoudre l'ambiguïté, le compilateur recherche la conversion implicite d'arguments pour correspondre aux signatures. Si une conversion implicite entraîne une correspondance de signature, la liaison est effectuée. Sinon, le compilateur génère une erreur.

Nous allons examiner divers exemples tout au long de cet article pour comprendre le fonctionnement du compilateur dans différents types de surcharge de méthode.

Types de surcharge de méthode en C #

Nous discutons ici les différents types de surcharge de méthode en C # ci-dessous:

1. Nombre différent de paramètres

La première catégorie et la plus simple de surcharge de méthode est lorsque les méthodes ont un nombre différent de paramètres dans leurs signatures.

Code

L'exemple ci-dessous est assez simple et est une évidence.

using System;
public class Program
(
public static void Main()
(
Func(10);)
public static void Func(int a)
(
Console.WriteLine("Single Parameter");
)public static void Func(int a, int b)
(
Console.WriteLine("Multiple Parameters");
)
)

Production:

2. Différents types de paramètres

Lorsque les signatures de méthode ont un ou plusieurs paramètres qui diffèrent par les types. Le nombre de paramètres peut être identique ou non.

Exemple 1

Dans l'exemple ci-dessous, les deux méthodes attendent un seul argument. Ainsi, en fonction du type d'argument transmis lors de l'appel de méthode, le compilateur lie la définition de méthode appropriée.

Code

using System;
public class Program
(
public static void Main()
(
Func("Hello World");
)
public static void Func(int a)
(
Console.WriteLine("Integer Parameter");
)
public static void Func(string b)
(Console.WriteLine("String Parameter");
)
)

Production:

Exemple 2

Maintenant, laissez-nous réfléchir au compilateur. Nous surchargerions une méthode de type double et float. Nous savons qu'un entier peut toujours être implicitement converti en type flottant ainsi qu'en type double.

Lorsque nous transmettons un argument entier, le compilateur vérifie la conversion implicite et constate que la meilleure conversion possible est un entier à flotter. Par conséquent, la méthode float est appelée.

Code

using System;
public class Program
(
public static void Main()
(
Func(10);
)
public static void Func(double a)
(
Console.WriteLine("Double Parameter");
)
public static void Func(float b)
(
Console.WriteLine("Floating Point Parameter");
)
)

Production:

3. Ordre différent des paramètres

Lorsque le nombre et le type d'arguments sont identiques, mais l'ordre dans lequel ils sont transmis diffère.

Exemple 1

L'exemple ci-dessous est assez simple.

Code

using System;
public class Program
(
public static void Main()
(
Func(10, 0.1);
)
public static void Func(int a, double b)
(
Console.WriteLine("Int-Double Parameters");
)
public static void Func(double a, int b)
(
Console.WriteLine("Double-Int Parameter");
)
)

Production:

Exemple 2

Que se passerait-il lorsque nous passerions deux arguments entiers dans l'exemple ci-dessus? Découvrons-le.

Code

Func(10, 1);

Production:

4. Paramètres facultatifs

Lorsque nous définissons un paramètre facultatif dans la signature de la méthode, le compilateur le traite comme une surcharge de méthode.

Remarque: Cela a priorité sur la conversion implicite.

Comprenons cela avec un exemple.

Exemple

Dans l'exemple ci-dessous, nous donnons au compilateur deux choix. Soit il peut implicitement convertir l'argument pour correspondre à la signature de la méthode. Ou il peut transmettre la valeur par défaut de l'argument facultatif. Le compilateur préfère cette dernière approche.

Code

using System;
public class Program
(
public static void Main()
(
Func(10);
)
public static void Func(int a, int b = 1)
(
Console.WriteLine("Int-Int Parameters");
)
public static void Func(double a)
(
Console.WriteLine("Double Parameter");
)
)

Production:

5. Arguments nommés

C # a une autre fonctionnalité de passer le nom des arguments lors de l'appel de la méthode. Cela aide également à surcharger les méthodes. Les développeurs peuvent choisir d'appeler une méthode particulière même si l'argument passé aurait par défaut appelé une autre méthode. Cependant, les méthodes surchargées doivent différer dans la signature.

Exemple

Dans l'exemple ci-dessous, nous demandons au compilateur d'appeler une méthode particulière en passant le nom du paramètre. Le compilateur suspend ensuite sa logique de détermination de la méthode la mieux adaptée.

Code

using System;
public class Program
(
public static void Main()
(
Func(b: 10);
)
public static void Func(int a)
(
Console.WriteLine("Int-Int Parameters");
)
public static void Func(double b)
(
Console.WriteLine("Double Parameter");
)
)

Production:

Règles de surcharge de méthode en C #

Les règles suivantes doivent être gardées à l'esprit lors de la surcharge des méthodes dans votre application C #.

  • La signature de la méthode doit être différente. Le nombre d'arguments, le type d'arguments ou l'ordre des arguments doivent être différents.
  • Le type de retour des méthodes ne joue aucun rôle dans la surcharge des méthodes.
  • Les paramètres facultatifs ont priorité sur la conversion de type implicite lors du choix de la définition de méthode à lier.
  • La conversion de type implicite a priorité sur la méthode de classe parent.
    Exercice - Pour comprendre cela, voici un petit exercice pour vous. Créez une classe parent avec une méthode qui attend un entier. Héritez une classe enfant. Surchargez la méthode de la classe parent dans la classe enfant de telle sorte que la méthode de la classe enfant attend un argument de type double. Créez un objet de classe enfant et appelez la méthode surchargée en passant un entier. Voyez ce qui se passe.

Conclusion

La surcharge de méthode est un concept assez puissant. Il est très utile pour écrire du code élégant. Pourtant, cela peut aller dans une certaine mesure lorsque des dizaines de méthodes sont surchargées, et le développeur doit se référer aux définitions de méthode tout en déboguant les appels erronés. Pour éviter cela, il est souvent suggéré de nommer vos méthodes différemment lorsque la surcharge a tendance à évoluer à un niveau supérieur.

Articles recommandés

Ceci est un guide de surcharge en C #. Nous discutons ici de sa méthode, de son fonctionnement, des types avec exemple et des règles. Vous pouvez également consulter nos autres articles suggérés pour en savoir plus -

  1. Boucle C #
  2. Instruction C # if
  3. Fonctions C #
  4. Utilisations de C #
  5. Guide de surcharge en C ++
  6. Surcharge en Java
  7. Surcharge Python
  8. Surcharge et remplacement en C #
  9. Conversion de types en Java avec types et exemples