Surcharge de méthode C#

Dans cet article, vous découvrirez la surcharge de méthodes en C# à l'aide d'exemples.

En C#, il peut y avoir deux méthodes ou plus dans une classe avec le même nom mais des nombres, des types et un ordre de paramètres différents, c'est ce qu'on appelle la surcharge de méthode. Par exemple :

void display() { ... }
void display(int a) { ... }
float display(double a) { ... }
float display(int a, float b) { ... }

Ici, le display() méthode est surchargée. Ces méthodes ont le même nom mais acceptent des arguments différents.

Remarque :Les types de retour des méthodes ci-dessus ne sont pas les mêmes. C'est parce que la surcharge de méthode n'est pas associée aux types de retour. Les méthodes surchargées peuvent avoir des types de retour identiques ou différents, mais elles doivent avoir des paramètres différents.

Nous pouvons effectuer une surcharge de méthode des manières suivantes :

1. En modifiant le nombre de paramètres

Nous pouvons surcharger la méthode si le nombre de paramètres dans les méthodes est différent.

void display(int a) {
  ...
} 
...
void display(int a, int b) {
  ...
}

Ici, nous avons deux méthodes dans une classe avec le même nom - display() . Il est possible d'avoir plus d'une méthode avec le même nom car le nombre de paramètres dans les méthodes est différent. Par exemple,

using System;

namespace MethodOverload {

  class Program {  

    // method with one parameter
    void display(int a) {
      Console.WriteLine("Arguments: " + a);
    }
 
    // method with two parameters
    void display(int a, int b) {
      Console.WriteLine("Arguments: " + a + " and " + b);
    } 
    static void Main(string[] args) {

      Program p1 = new Program();
      p1.display(100);
      p1.display(100, 200);
      Console.ReadLine();
    }
  }
}

Sortie

Arguments: 100
Arguments: 100 and 200

Dans l'exemple ci-dessus, nous avons surchargé display() méthode :

une méthode a un paramètre
un autre a deux paramètres

En fonction du numéro de l'argument passé lors de l'appel de la méthode, la méthode correspondante est appelée.

p1.display(100) - appelle la méthode avec un seul paramètre
p1.display(100, 200) - appelle la méthode avec deux paramètres

2. En modifiant les types de données des paramètres

void display(int a) {
  ...
} 
...
void display(string b) {
  ...
}

Ici, nous avons deux méthodes - display() avec le même nombre de paramètres. Il est possible d'avoir plus d'un display() méthode avec le même nombre de paramètres car le type de données des paramètres dans les méthodes est différent. Par exemple,

using System;

namespace MethodOverload {

  class Program {  

    // method with int parameter
    void display(int a) {
      Console.WriteLine("int type: " + a);
    } 

    // method with string parameter
    void display(string b) {
      Console.WriteLine("string type: " + b);
    } 
    static void Main(string[] args) {

      Program p1 = new Program();
      p1.display(100);
      p1.display("Programiz");
      Console.ReadLine();
    }
  }
}

Sortie

int type: 100
string type: Programiz

Dans le programme ci-dessus, nous avons surchargé le display() méthode avec différents types de paramètres.

En fonction du type d'arguments passés lors de l'appel de la méthode, la méthode correspondante est appelée.

p1.display(100) - appelle la méthode avec int paramètre de type
p1.display("Programiz") - appelle la méthode avec string paramètre de type

3. En modifiant l'Ordre des paramètres

void display(int a, string b) {
  ...
} 
...
void display(string b, int a) {
  ...
}

Ici, nous avons deux méthodes - display() . Il est possible d'avoir plus d'un display() méthode avec le même nombre et le même type de paramètre car l'ordre du type de données des paramètres dans les méthodes est différent. Par exemple,

using System;

namespace MethodOverload {

  class Program {  

    // method with int and string parameters 
    void display(int a, string b) {
      Console.WriteLine("int: " + a);
      Console.WriteLine("string: " + b);
    } 

    // method with string andint parameter
    void display(string b, int a) {
      Console.WriteLine("string: " + b);
      Console.WriteLine("int: " + a);
    } 
    static void Main(string[] args) {

      Program p1 = new Program();
      p1.display(100, "Programming");
      p1.display("Programiz", 400);
      Console.ReadLine();
    }
  }
}

Sortie

int: 100
string: Programming
string: Programiz
int: 400

Dans le programme ci-dessus, nous avons surchargé le display() méthode avec différents ordres de paramètres.

En fonction de l'ordre des arguments passés lors de l'appel de la méthode, la méthode correspondante est appelée.

p1.display(100, "Programming") - appelle la méthode avec int et string paramètre respectivement
p1.display("Programiz", 400) - appelle la méthode avec string et int paramètre respectivement

Interface C# Surcharge du constructeur C#

Langue C