Mehrere Werte von einer Funktion in C# zurückgeben

1. Rückgabe mehrerer Werte von einer Funktion mit den Arrays in C#
2. Rückgabe mehrerer Werte von einer Funktion mit den Struktur- / Klassenobjekten in C#
3. Rückgabe mehrerer Werte von einer Funktion mit der Klasse Tuples<T1,T2> in C#
4. Rückgabe mehrerer Werte von einer Funktion mit der Notation (T1,T2) in C#

In diesem Lernprogramm werden die Methoden zum Zurückgeben mehrerer Werte von einer Funktion in C# vorgestellt.

Rückgabe mehrerer Werte von einer Funktion mit den Arrays in C#

Die Array-Datenstruktur speichert mehrere Werte desselben Datentyps in C#. Wir können Arrays verwenden, um mehrere Werte von einer Funktion zurückzugeben. Das folgende Codebeispiel zeigt, wie Sie mithilfe von Arrays mehrere Werte von einer Funktion in C# zurückgeben.

using System;

namespace return_multipe_values {
  class Program {
    public static int[] compare(int a, int b) {
      int[] arr = new int[2];
      if (a > b) {
        arr[0] = b;
        arr[1] = a;
      } else {
        arr[0] = a;
        arr[1] = b;
      }
      return arr;
    }
    static void Main(string[] args) {
      int[] returnvalue = Program.compare(10, 12);
      Console.WriteLine("Smaller Value = {0}", returnvalue[0]);
      Console.WriteLine("Larger Value = {0}", returnvalue[1]);
    }
  }
}

Ausgabe:

Smaller Value = 10
Larger Value = 12

Wir haben 2 ganzzahlige Werte von der Funktion compare() mit dem Array-Rückgabetyp in C# zurückgegeben. Diese Methode ist nützlich, wenn Sie mehrere Werte desselben Datentyps zurückgeben müssen. Wenn Sie mehrere Werte unterschiedlicher Datentypen zurückgeben möchten, können Sie kein Array verwenden, da in einem Array nur Werte desselben Datentyps gespeichert werden.

Rückgabe mehrerer Werte von einer Funktion mit den Struktur- / Klassenobjekten in C#

Die Strukturen und Klassen werden verwendet, um verwandte Werte zu gruppieren. Die Werte müssen nicht vom gleichen Datentyp sein. Daher können wir eine Struktur oder ein Klassenobjekt verwenden, um mehrere Werte von einer Funktion in C# zurückzugeben. Das folgende Codebeispiel zeigt uns, wie wir ein Strukturobjekt verwenden können, um mehrere Werte von einer Funktion in C# zurückzugeben.

using System;

namespace return_multipe_values {
  struct Values {
    public int x;
    public int y;
  }

  class Program {
    public static Values comparevalues(int a, int b) {
      Values V = new Values();
      if (a > b) {
        V.x = b;
        V.y = a;
      } else {
        V.x = a;
        V.y = b;
      }
      return V;
    }
    static void Main(string[] args) {
      Values returnedvalues = Program.comparevalues(10, 12);
      Console.WriteLine("Smaller Value = {0}", returnedvalues.x);
      Console.WriteLine("Larger Value = {0}", returnedvalues.y);
    }
  }
}

Ausgabe:

Smaller Value = 10
Larger Value = 12

Wir definieren zunächst eine Struktur, Values, die die Werte enthält, die wir von unserer Funktion zurückgeben möchten. Wir haben dann mehrere Werte aus der Funktion comparevalues() mit der Struktur Values als Rückgabetyp in C# zurückgegeben. Die zurückgegebenen Werte müssen auch in einer Instanz derselben Struktur gespeichert werden.

Dieses Ziel kann auch erreicht werden, indem eine Klasse als Rückgabetyp der Funktion verwendet wird. Der folgende Code zeigt uns, wie wir eine Klasse verwenden können, um mehrere Werte von einer Funktion in C# zurückzugeben.

using System;
public class Sample {
  int x;
  int y;
  public void setxy(int v, int u) {
    x = v;
    y = u;
  }
  public void getxy() {
    Console.WriteLine("The smaller value = {0}", x);
    Console.WriteLine("The greater value = {0}", y);
  }
}
public class Program {
  public static Sample compare(int a, int b) {
    Sample s = new Sample();
    if (a > b) {
      s.setxy(b, a);
    } else {
      s.setxy(a, b);
    }
    return s;
  }
  public static void Main() {
    Sample returnedobj = Program.compare(10, 12);
    returnedobj.getxy();
  }
}

Ausgabe:

The smaller value = 10
The greater value = 12

Wir definieren zunächst eine Klasse Sample, die die Werte enthält, die wir von unserer Funktion zurückgeben möchten. Wir haben dann mehrere Werte aus der Funktion compare() mit der Klasse Sample als Rückgabetyp der Funktion in C# zurückgegeben. Die zurückgegebenen Werte müssen auch in einer Instanz derselben Klasse gespeichert werden. Obwohl beide Methoden hervorragend geeignet sind, um mehrere Werte verschiedener Datentypen von einer Funktion zurückzugeben, ist das Schreiben einer ganzen Klasse oder Struktur, um nur mehrere Werte von einer Funktion zurückzugeben, sehr mühsam und zeitaufwändig.

Rückgabe mehrerer Werte von einer Funktion mit der Klasse Tuples<T1,T2> in C#

Ein Tupel ist eine Datenstruktur mit einer bestimmten Nummer und einer bestimmten Reihenfolge von Werten in C#. Ein Tupel kann mehrere Werte unterschiedlicher Datentypen haben. Mit der Klasse Tuple<T1, T2> können benutzerdefinierte Tupel mit benutzerdefinierten Datentypen in einer bestimmten Reihenfolge definiert werden. Das folgende Codebeispiel zeigt uns, wie wir mehrere Werte von einer Funktion mit der Klasse Tuple<T1,T2> in C# zurückgeben können.

using System;

public class Program {
  public static Tuple<string, string, int> ReturnMultipleValues() {
    var result = Tuple.Create<string, string, int>("value1", "value2", 3);
    return result;
  }
  public static void Main() {
    var returnedvalues = ReturnMultipleValues();
    Console.WriteLine(returnedvalues);
  }
}

Ausgabe:

(value1, value2, 3)

Wir geben mehrere Werte von der Funktion ReturnMultipleValues() zurück, indem wir den Rückgabetyp der Funktion mit Tuple<string, string, int> angeben. Dies bedeutet, dass die Funktion ReturnMultipleValues() 3 Werte mit den ersten beiden Werten des Datentyps string und dem letzten Wert des Datentyps int zurückgibt. Dieser Rückgabewert kann entweder in einem Tupel einer ähnlichen Struktur oder in einer Variablen vom Typ var gespeichert werden.

Rückgabe mehrerer Werte von einer Funktion mit der Notation (T1,T2) in C#

Der obige Abschnitt, in dem erläutert wird, wie die Klasse Tuple<T1,T2> verwendet wird, um das Zurückgeben mehrerer Werte von einer Funktion zu vereinfachen, kann mit der Notation (T1, T2) zum Deklarieren von Tupeln weiter verkürzt werden. Die Notation (T1, T2) macht dasselbe wie die Klasse Tuple<T1,T2>, indem sie auch den Code verkürzt. Das folgende Codierungsbeispiel zeigt uns, wie wir die Notation (T1, T2) verwenden können, um mehrere Werte von einer Funktion in C# zurückzugeben.

using System;

public class Program {
  public static (string, string, int) ReturnMultipleValues() {
    return ("value1", "value2", 3);
    ;
  }
  public static void Main() {
    (string val1, string val2, int val3) = ReturnMultipleValues();
    Console.WriteLine("{0} {1} {2}", val1, val2, val3);
  }
}

Ausgabe:

value1 value2 3

Im obigen Code haben wir mehrere Werte von der Funktion ReturnMultipleValues() mit der Notation (T1,T2) in C# zurückgegeben.