Wie gibt man 2 oder 3 Werte mit Tuple zurück?

Question

Also mache ich ein albernes Spiel in C#, aber ich bin hier ein bisschen fest.

Ich versuche entweder 2 Werte oder 3 Werte zurückzugeben, hängt von den Regeln des Spiels ab.

Ich muss wissen, wie ich verschiedene Mengen von Werten in nur einer Funktion zurückgeben kann. Wie manchmal muss ich 3 Werte und manchmal 7 Werte ... in einer Funktion zurückgeben.

Der Fehler ist mit der Variablen tuple natürlich, da ich nicht weniger als 3 Werte zurückgeben können ..

public Tuple<int, int, int> movepion(schaken.pion pion, int row, int column) 
{ 
    int row2 = row + 1; 

    //posities berekenen 
    if (pion.kleur == Color.Blue) 
    { 
     if (pion.volgnr == 0) { row++; row2++; } 
     else { row++; } 
    } 
    else 
    { 
    } 

    // declaration 
    var tuple = new Tuple<int, int>(row, column); 
    var tuple2 = new Tuple<int, int, int>(row, row2, column); 

    // what position? 
    if (pion.volgnr == 0) 
    { 
     pion.volgnr = pion.volgnr + 1; 
     return tuple2; 
    } 
    else 
    { 
     return tuple; 
    } 
} 

Answer 1

Return eine Sammlung statt einem Tuple<>

public IEnumerable<int> movepion(schaken.pion pion, int row, int column) 
{ 
    IEnumerable<int> result; 
    bool return2Items = false; //Some logic part to decide how many items to return 
    if(return2Items) 
     result = new List<int> { 1, 2 }; 
    else 
     result = new List<int> { 1, 2, 3 }; 

    return result;  
} 

---

Nachdem die besser auf die Kommentare zu verstehen, würde ich empfehlen, ein Objekt MoveOption und dass die Funktion zurück IEnumerable<MoveOption>

public class MoveOption 
{ 
    public int X { get; set; } 
    public int Y { get; set; } 
} 

zu erstellen Dann in Ihrer Funktion:

public IEnumerable<MoveOption> movepion(schaken.pion pion, int row, int column) 
{ 
    List<MoveOption> options = new List<MoveOption>(); 

    if(/*some condition*/) 
    { 
     options.Add(new MoveOption{ X = 1, Y = 2 }); 
    } 

    if(/*some condition*/) 
    { 
     options.Add(new MoveOption{ X = 5, Y = 7 }); 
    } 

    //Rest of options 

    return options; 
} 

Dann, wenn Sie es einen Schritt machen wollen vorwärts können Sie die Vererbung verwenden und:

public interface IMoveOptionCalcumator 
{ 
    public MoveOption Calculate(/*input*/); 
} 

public class MoveOptionX : IMoveOptionCalcumator 
{ 
    public MoveOption Calculate(/*input*/) { /*some implementation*/ } 
} 

Und in Ihrer Funktion:

public class YourClass 
{ 
    public IEnumerable<IMoveOptionCalcumator> MoveOptionCalculators { get; set; } 

    public YourClass() 
    { 
     // Initialize the collection of calculators 
     // You can look into Dependency Injection if you want even another step forward :) 
    } 


    public IEnumerable<int> movepion(schaken.pion pion, int row, int column) 
    { 
     List<MoveOption> options = new List<MoveOption>(); 
     foreach (var item in MoveOptionsCalculators) 
     { 
      var result = item.Calculate(/*input*/); 
      if(result != null) 
      { 
       options.Add(result); 
      } 
     } 
     return options; 
    } 
} 

Answer 2

Versuchen Sie, den Rückgabetyp zu

Tuple<int, int, int?> 

Auf diese Weise ändert würden Sie haben

Wie auch immer, ich denke, es wäre am besten, die Semantik der Methode und Pro zu klären Möglicherweise haben Sie einen aussagekräftigen benutzerdefinierten Datentyp zurückgegeben.