Return mehrere Werte an eine Methode Aufrufer

Nun, dass C# 7 veröffentlicht wurde, können Sie mit der neuen im Lieferumfang enthalten Tupeln syntax

(string, string, string) LookupName(long id) //tuple return type
{
    ... //retrieve first, middle and last from data storage
    return (first, middle, last); //tuple literal
}

könnte dann z.B. so verwendet werden:

var names = LookupName(id);
WriteLine($"found {names.Item1} {names.Item3}.");

Können Sie auch die Namen Ihrer Elemente (Sie sind also nicht "Item1", "Item2", etc). Sie können es durch hinzufügen einen Namen für die Signatur oder die Rückkehr Methoden:

(string first, string middle, string last) LookupName(long id) //tuple elements have names

oder

return (first: first, middle: middle, last: last); //named tuple elements in a literal

Können Sie auch dekonstruiert werden, was ein ziemlich nettes neues feature:

(string first, string middle, string last) = LookupName(id1); //deconstructing declaration

Check-out dieser link mehr Beispiele zu sehen, was getan werden kann 🙂

Können Sie nicht tun, diese in C#. Was Sie tun können, ist eine out parameter oder Rückgabe Ihrer eigenen Klasse (oder struct, wenn Sie wollen, dass es unveränderbar).

Mithilfe der out-parameter

public int GetDay(DateTime date, out string name)
{
  //...
}

Mit custom class (oder struct)

public DayOfWeek GetDay(DateTime date)
{
  //...
}

public class DayOfWeek
{
  public int Day { get; set; }
  public string Name { get; set; }
}

Bisherigen poster Recht. Sie können nicht zurückgeben mehrerer Werte aus einer C# - Methode. Sie haben jedoch ein paar Optionen:

• Eine Struktur enthält, die mehrere Mitglieder
• Return eine Instanz einer Klasse
• Verwenden Sie output-Parameter (mit der aus oder ref keywords)
• Verwenden Sie ein Wörterbuch oder Schlüssel-Wert-paar als Ausgang

Die vor-und Nachteile hier sind oft schwer herauszufinden. Wenn Sie eine Struktur, stellen Sie sicher, es ist klein, weil structs sind value-Typ und auf den stack gelegt. Wenn Sie eine Instanz einer Klasse, gibt es einige design-patterns hier, dass Sie möglicherweise verwenden möchten, um zu vermeiden, dass Probleme - Mitglieder der Klassen geändert werden können, da C# übergibt Objekte per Referenz (die Sie nicht haben, ByVal wie in VB).

Schließlich können Sie die Ausgabe-Parameter würde ich aber begrenzen Sie die Nutzung dieser Szenarien, wenn Sie nur ein paar (3 oder weniger) der Parameter - sonst werden die Dinge unschön und schwer zu pflegen. Auch die Verwendung von output-Parametern kann ein inhibitor der Beweglichkeit, weil Sie Ihre Methode, die Signatur zu ändern jedes mal müssen Sie etwas hinzufügen, um die Rückkehr Wert in der Erwägung, dass die Rückgabe einer struct oder class-Instanz können Sie Mitglieder hinzufügen, ohne änderungen an der Signatur der Methode.

Aus architektonischer Sicht würde ich empfehlen gegen die Verwendung von Schlüssel-Wert-Paare oder Wörterbücher. Ich finde diese Art der Codierung erfordert "geheimes wissen" im code, verbraucht der Methode. Es muss im Voraus wissen, was die Schlüssel sind und was die Werte bedeuten und ob die Entwickler auf die interne Implementierung ändert die Art, wie das Wörterbuch oder KVP ist geschaffen, es könnte leicht erstellen Sie eine Fehler-Kaskade während der gesamten Anwendung.

Gibt es mehrere Möglichkeiten, dies zu tun. Sie können ref Parameter:

int Foo(ref Bar bar) { }

Diese übergibt eine Referenz auf die Funktion und somit ist die Funktion zum ändern des Objekts in der aufrufenden code-stack. Dies ist, zwar nicht technisch ein "zurück" - Wert es ist ein Weg, um eine Funktion etwas ähnliches tun. In den obigen code die Funktion zurückkehren würde, ein int und (potenziell) ändern bar.

Anderen ähnlichen Ansatz ist die Verwendung einer out parameter. Ein out parameter ist identisch zu einem ref parameter mit einem zusätzlichen, compiler erzwungen Regel. Diese Regel ist, dass, wenn Sie übergeben eine out parameter in einer Funktion, die Funktion wird benötigt, um Ihren Wert vor der Rückgabe. Außerdem gilt, dass ein out parameter funktioniert genau wie ein ref parameter.

Den Endanflug (und das am besten in den meisten Fällen) ist das erstellen einer Art Gesamtschau beider Werte und die Funktion ermöglichen zurückkehren:

class FooBar 
{
    public int i { get; set; }
    public Bar b { get; set; }
}

FooBar Foo(Bar bar) { }

Dieser Letzte Ansatz ist einfacher und leichter zu Lesen und zu verstehen.

In C# 4, werden Sie in der Lage, mithilfe der integrierten Unterstützung für Tupeln, die dies leicht zu handhaben.

In der Zwischenzeit gibt es zwei Möglichkeiten.

Ersten, die Sie verwenden können, ref-oder out-Parameter zum zuweisen von Werten an die Parameter, die übergeben wieder an die aufrufende routine.

Diese sieht wie folgt aus:

void myFunction(ref int setMe, out int youMustSetMe);

Zweitens können Sie wickeln Ihre Rückgabewerte in eine Struktur oder Klasse, und übergeben Sie Sie wieder als Mitglieder dieser Struktur. KeyValuePair funktioniert gut für 2 - für mehr als 2 brauchst du ein custom class oder struct.

Einige Antworten schlagen vor, mit out-Parameter aber ich empfehle
nicht mit dieser aufgrund Sie arbeiten nicht mit async-Methoden. Sehen
diese für weitere Informationen.

Anderen Antworten angegeben mit Tupel, das würde ich empfehlen, auch, aber mit dem neuen feature in C# 7.0.

(string, string, string) LookupName(long id) //tuple return type
{
    ... //retrieve first, middle and last from data storage
    return (first, middle, last); //tuple literal
}

var names = LookupName(id);
WriteLine($"found {names.Item1} {names.Item3}.");

Weitere Informationen finden Sie hier.

Klassen, Strukturen, Collections und Arrays können mehrere Werte enthalten. Ausgangs-und Referenz-Parameter können Sie auch in eine Funktion. Rückgabe mehrerer Werte möglich ist, in dynamischen und funktionalen Sprachen mit Hilfe von Tupeln, aber nicht in C#.

Hier sind grundlegende Two Methoden:

1) die Nutzung der 'out' als parameter
Sie können 'aus' für beide 4.0 und minor-Versionen zu.

Beispiel von 'out':

using System;

namespace out_parameter
{
  class Program
   {
     //Accept two input parameter and returns two out value
     public static void rect(int len, int width, out int area, out int perimeter)
      {
        area = len * width;
        perimeter = 2 * (len + width);
      }
     static void Main(string[] args)
      {
        int area, perimeter;
        //passing two parameter and getting two returning value
        Program.rect(5, 4, out area, out perimeter);
        Console.WriteLine("Area of Rectangle is {0}\t",area);
        Console.WriteLine("Perimeter of Rectangle is {0}\t", perimeter);
        Console.ReadLine();
      }
   }
}

Ausgabe:

Fläche des Rechtecks ist 20

Umfang von Rechteck ist 18

*Hinweis:*Die out-Schlüsselwort beschreibt Parameter, deren tatsächliche variable Speicherorte kopiert werden, auf den stack der aufgerufenen Methode, wo die gleichen stellen geschrieben werden kann. Dies bedeutet, dass die aufrufende Methode auf das zu verändernde parameter.

2) Tuple<T>

Beispiel-Tupel:

Rückkehr Mehrere DataType-Werte mit Tuple<T>

using System;

class Program
{
    static void Main()
    {
    //Create four-item tuple; use var implicit type.
    var tuple = new Tuple<string, string[], int, int[]>("perl",
        new string[] { "java", "c#" },
        1,
        new int[] { 2, 3 });
    //Pass tuple as argument.
    M(tuple);
    }

    static void M(Tuple<string, string[], int, int[]> tuple)
    {
    //Evaluate the tuple's items.
    Console.WriteLine(tuple.Item1);
    foreach (string value in tuple.Item2)
    {
        Console.WriteLine(value);
    }
    Console.WriteLine(tuple.Item3);
    foreach (int value in tuple.Item4)
    {
        Console.WriteLine(value);
    }
    }
}

Ausgabe

perl
java
c#
1
2
3

HINWEIS: Verwendung der Tupel ist gültig ab dem Framework 4.0 und höher.Tuple Typ ist ein class. Es wird vergeben werden in einen separaten Speicherort auf dem verwalteten heap im Speicher. Wenn Sie erstellen die Tuple Sie können nicht ändern, die Werte seiner fields. Dies macht die Tuple mehr wie ein struct.

Nur die Verwendung in OOP-Manier ein Klasse wie folgt aus:

class div
{
    public int remainder;

    public int quotient(int dividend, int divisor)
    {
        remainder = ...;
        return ...;
    }
}

Funktion Mitglied gibt der quotient die meisten Anrufer sind in Erster Linie interessiert. Zusätzlich speichert es den Rest als Daten-member, die leicht zugänglich durch die Anrufer danach.

Diese Weise können Sie viele weitere "Rückkehr der Werte", sehr nützlich, wenn Sie implementieren von Datenbank-oder Netzwerk-Anrufe, wo eine Menge von Fehlermeldungen, die möglicherweise notwendig werden, aber nur im Fall, dass ein Fehler Auftritt.

Betrat ich diese Lösung auch in C++ Frage, dass OP sich bezieht.

Zukünftigen version von C# wird named Tupel.
Haben Sie einen Blick auf das channel9-Sitzung für die demo
https://channel9.msdn.com/Events/Build/2016/B889

Überspringen, um 13:00 Uhr-für das Tupel Zeug. Dies wird es ermöglichen, Sachen wie:

(int sum, int count) Tally(IEnumerable<int> list)
{
//calculate stuff here
return (0,0)
}

int resultsum = Tally(numbers).sum

(unvollständige Beispiel aus dem video)

<--Return more statements like this you can --> 

public (int,string,etc) Sample( int a, int b)  
{
    //your code;
    return (a,b);  
}

Können Sie erhalten code wie

(c,d,etc) = Sample( 1,2);

Ich hoffe, dass es funktioniert.

können Sie versuchen, diese

public IEnumerable<string> Get()
 {
     return new string[] { "value1", "value2" };
 }

Heute, Programmierer Zeit brauchen, & unforgotable Methoden.
Eine einfache, funktionierende und schnelle Lösung:

private int[] SumAndSub(int A, int B)
{
    return new[] { A + B , A - B };
}

Verwendung in irgendwo;

var results = SumAndSub(20, 5);
int sum = results[0];
int sub = results[0];