¿Cuál es la mejor manera de devolver dos listas en C#?

coding-style

Question

Estoy casi avergonzado de hacer esta pregunta, pero como programador de C desde hace mucho tiempo, siento que quizás no conozco la mejor manera de hacerlo en C #.

Tengo una función miembro que necesito para devolver dos listas de un tipo personalizado ( List<MyType> ) y sé de antemano que siempre tendré un valor de retorno de solo dos de estas listas.

Las opciones obvias son:

public List<List<MyType>> ReturnTwoLists();

o

public void ReturnTwoLists(ref List<MyType> listOne, ref List<myType> listTwo);

Ambos parecen ser no óptimos.

¿Alguna sugerencia sobre cómo mejorar esto?

La primera forma no deja claro en la sintaxis que solo se devuelven 2 listas, y la segunda usa referencias en lugar de un valor de retorno, que parece no ser c #.

Answer 1

¿Crear una estructura simple que contenga ambas y devolverlas como salida de la función?

Answer 2

Devuelve esto:

public class MyTwoLists {
    public List<MyType> ListOne {get;set;}
    public List<MyType> ListTwo {get;set;}
}

Answer 3

En primer lugar, probablemente debería estar out , no ref .

En segundo lugar, puede declarar y devolver un tipo que contenga las dos listas.

Tercero, puedes declarar un Tuple genérico y devolver una instancia de eso:

class Tuple<T,U> {
   public Tuple(T first, U second) { 
       First = first;
       Second = second;
   }
   public T First { get; private set; }
   public U Second { get; private set; }
}

static class Tuple {
   // The following method is declared to take advantage of
   // compiler type inference features and let us not specify
   // the type parameters manually.
   public static Tuple<T,U> Create<T,U>(T first, U second) {
        return new Tuple<T,U>(first, second);
   }
}

return Tuple.Create(firstList, secondList);

Puede ampliar esta idea para diferentes número de elementos.

Answer 4

Tienes pocas opciones:

use un par si las listas no tienen sentido en orden:

 public Pair<List<MyType>,List<MyType> ReturnTwoLists()
 {
        return new Pair(new List<MyType(), new List<MyType());
 }

Puede utilizar los parámetros de fuera o ref , como ha mencionado. Esta es una buena opción si una lista es más significativa que la otra.

Puede usar un diccionario si el cliente conoce las claves o quiere hacer el trabajo para buscarlas:

 public Dictionary<string,List<MyType> ReturnTwoLists()
 {
        Dictionary<string,List<MyTpe>> d = new Dictionary<string,List<MyType>>();
        d.Add("FirstList",new List<MyType>());
        d.Add("SecondList",new List<MyType>());
        return new Dictionary()(new List<MyType(), new List<MyType());
 }

O, en mi opinión, la solución más "correcta", por integridad y coherencia, sería crear una clase de contenedor de datos simple para contener las dos listas. Esto proporciona a los consumidores valores de retorno bien compilados, compilados estáticamente (leídos: habilitados para inteligencia) con los que trabajar. La clase se puede anidar justo al lado del método.

Answer 5

Tu primera sugerencia no son dos listas. Es una lista de listas.

La segunda opción haría lo que pretendía, pero es posible que desee cambiarla para usar la palabra clave out en lugar de ref, de modo que las personas que llaman a su método conozcan la intención de lo que está haciendo.

public void ReturnTwoLists(out List<MyType> listOne, out List<myType> listTwo);