Überladen von C#-Methoden

C#-Methodenüberladung

In diesem Artikel erfahren Sie anhand von Beispielen mehr über das Überladen von Methoden in C#.

In C# gibt es möglicherweise zwei oder mehr Methoden in einer Klasse mit demselben Namen, aber unterschiedlicher Anzahl, Typen und Reihenfolge der Parameter. Dies wird als Methodenüberladung bezeichnet. Zum Beispiel:

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

Hier das display() Methode ist überladen. Diese Methoden haben denselben Namen, akzeptieren aber unterschiedliche Argumente.

Hinweis :Die Rückgabetypen der oben genannten Methoden sind nicht identisch. Dies liegt daran, dass das Überladen von Methoden nicht mit Rückgabetypen verknüpft ist. Überladene Methoden können dieselben oder unterschiedliche Rückgabetypen haben, aber sie müssen unterschiedliche Parameter haben.

---

Wir können das Überladen von Methoden auf folgende Weise durchführen:

1. Durch Ändern der Parameteranzahl

Wir können die Methode überladen, wenn die Anzahl der Parameter in den Methoden unterschiedlich ist.

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

Hier haben wir zwei Methoden in einer Klasse mit demselben Namen - display() . Es ist möglich, mehr als eine Methode mit demselben Namen zu haben, da die Anzahl der Parameter in Methoden unterschiedlich ist. Zum Beispiel

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

Ausgabe

Arguments: 100
Arguments: 100 and 200

Im obigen Beispiel haben wir display() überladen Methode:

• Eine Methode hat einen Parameter
• ein anderer hat zwei Parameter

Basierend auf der Nummer des beim Methodenaufruf übergebenen Arguments wird die entsprechende Methode aufgerufen.

• p1.display(100) - ruft die Methode mit einem einzigen Parameter auf
• p1.display(100, 200) - ruft die Methode mit zwei Parametern auf

---

2. Durch Ändern der Datentypen der Parameter

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

Hier haben wir zwei Methoden - display() mit der gleichen Anzahl von Parametern. Es ist möglich, mehr als ein display() zu haben Methode mit der gleichen Anzahl von Parametern, da der Datentyp von Parametern in Methoden unterschiedlich ist. Zum Beispiel

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

Ausgabe

int type: 100
string type: Programiz

Im obigen Programm haben wir display() überladen Methode mit verschiedenen Arten von Parametern.

Basierend auf dem Typ der Argumente, die während des Methodenaufrufs übergeben werden, wird die entsprechende Methode aufgerufen.

• p1.display(100) - ruft Methode mit int auf Typparameter
• p1.display("Programiz") - ruft Methode mit string auf Typparameter

---

3. Durch Ändern der Reihenfolge der Parameter

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

Hier haben wir zwei Methoden - display() . Es ist möglich, mehr als ein display() zu haben Methode mit der gleichen Anzahl und dem gleichen Parametertyp, da die Reihenfolge der Datentypen von Parametern in Methoden unterschiedlich ist. Zum Beispiel

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

Ausgabe

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

Im obigen Programm haben wir display() überladen Methode mit unterschiedlichen Reihenfolgen von Parametern.

Basierend auf der Reihenfolge der beim Methodenaufruf übergebenen Argumente wird die entsprechende Methode aufgerufen.

• p1.display(100, "Programming") - ruft Methode mit int auf und string Parameter
• p1.display("Programiz", 400) - Methode mit string aufrufen und int Parameter