Devolver múltiples valores a un llamador de método
Leí la versión C++ de esta pregunta pero realmente no la entendí.
¿Alguien puede explicar claramente si se puede hacer en C# y cómo?
Ahora que se lanzó C# 7, puede usar la nueva sintaxis de Tuplas incluida.
(string, string, string) LookupName(long id) // tuple return type
{
... // retrieve first, middle and last from data storage
return (first, middle, last); // tuple literal
}
que luego podría usarse así:
var names = LookupName(id);
WriteLine($"found {names.Item1} {names.Item3}.");
También puede proporcionar nombres a sus elementos (para que no sean "Elemento1", "Elemento2", etc.). Puedes hacerlo agregando un nombre a la firma o los métodos de devolución:
(string first, string middle, string last) LookupName(long id) // tuple elements have names
o
return (first: first, middle: middle, last: last); // named tuple elements in a literal
También se pueden deconstruir, lo cual es una característica nueva bastante interesante:
(string first, string middle, string last) = LookupName(id1); // deconstructing declaration
Consulte este enlace para ver más ejemplos de lo que se puede hacer :)
En C# 7 y superior, consulte esta respuesta .
En versiones anteriores, puede utilizar Tuple de .NET 4.0+ :
Por ejemplo:
public Tuple<int, int> GetMultipleValue()
{
return Tuple.Create(1,2);
}
Las tuplas con dos valores tienen Item1y Item2como propiedades.
Puedes utilizar tres formas diferentes.
1. parámetros de referencia / salida
usando referencia:
static void Main(string[] args)
{
int a = 10;
int b = 20;
int add = 0;
int multiply = 0;
Add_Multiply(a, b, ref add, ref multiply);
Console.WriteLine(add);
Console.WriteLine(multiply);
}
private static void Add_Multiply(int a, int b, ref int add, ref int multiply)
{
add = a + b;
multiply = a * b;
}
usando:
static void Main(string[] args)
{
int a = 10;
int b = 20;
int add;
int multiply;
Add_Multiply(a, b, out add, out multiply);
Console.WriteLine(add);
Console.WriteLine(multiply);
}
private static void Add_Multiply(int a, int b, out int add, out int multiply)
{
add = a + b;
multiply = a * b;
}
2. estructura/clase
usando estructura:
struct Result
{
public int add;
public int multiply;
}
static void Main(string[] args)
{
int a = 10;
int b = 20;
var result = Add_Multiply(a, b);
Console.WriteLine(result.add);
Console.WriteLine(result.multiply);
}
private static Result Add_Multiply(int a, int b)
{
var result = new Result
{
add = a * b,
multiply = a + b
};
return result;
}
usando clase:
class Result
{
public int add;
public int multiply;
}
static void Main(string[] args)
{
int a = 10;
int b = 20;
var result = Add_Multiply(a, b);
Console.WriteLine(result.add);
Console.WriteLine(result.multiply);
}
private static Result Add_Multiply(int a, int b)
{
var result = new Result
{
add = a * b,
multiply = a + b
};
return result;
}
3. tupla
clase tupla
static void Main(string[] args)
{
int a = 10;
int b = 20;
var result = Add_Multiply(a, b);
Console.WriteLine(result.Item1);
Console.WriteLine(result.Item2);
}
private static Tuple<int, int> Add_Multiply(int a, int b)
{
var tuple = new Tuple<int, int>(a + b, a * b);
return tuple;
}
C# 7 tuplas
static void Main(string[] args)
{
int a = 10;
int b = 20;
(int a_plus_b, int a_mult_b) = Add_Multiply(a, b);
Console.WriteLine(a_plus_b);
Console.WriteLine(a_mult_b);
}
private static (int a_plus_b, int a_mult_b) Add_Multiply(int a, int b)
{
return(a + b, a * b);
}
