Crear una lista de listas en C#

Question

Parece que me está costando trabajo pensar en una Lista genérica de listas genéricas en C#. Creo que el problema radica en el uso del argumento <T>, con el que no tengo experiencia previa. ¿Podría alguien proporcionar un pequeño ejemplo de declaración de una clase que es una lista, que contiene otra lista, pero donde el tipo de objeto que contiene no se conoce inmediatamente?

He estado leyendo la documentación de MS sobre Generics, y no estoy seguro de inmediato si puedo declarar List<List<T>>, ni cómo pasar exactamente el parámetro <T> a la lista interna.

Editar: La adición de información

Would declarar una List<List<T>> considerarse legal aquí? En caso de que te lo estés preguntando, estoy creando una clase que me permite usar un ulong como indexador y (con suerte) pasos alrededor del desagradable límite 2GB de .Net manteniendo una lista de listas.

public class DynamicList64<T> 
    { 
     private List<List<T>> data = new List<List<T>>(); 

     private ulong capacity = 0; 
     private const int maxnumberofitemsperlist = Int32.MaxValue; 



     public DynamicList64() 
     { 
      data = new List<List<T>>(); 
     } 

Answer 1

Un ejemplo rápido:

List<List<string>> myList = new List<List<string>>(); 
myList.Add(new List<string> { "a", "b" }); 
myList.Add(new List<string> { "c", "d", "e" }); 
myList.Add(new List<string> { "qwerty", "asdf", "zxcv" }); 
myList.Add(new List<string> { "a", "b" }); 

// To iterate over it. 
foreach (List<string> subList in myList) 
{ 
    foreach (string item in subList) 
    { 
     Console.WriteLine(item); 
    } 
} 

¿Es eso lo que estabas buscando? ¿O está intentando crear un nuevo class que extienda List<T> que tenga un miembro que sea una "Lista"?

Answer 2

o este ejemplo, sólo para que sea más visible:

public class CustomerListList : List<CustomerList> { } 

public class CustomerList : List<Customer> { } 

public class Customer 
{ 
    public int ID { get; set; } 
    public string SomethingWithText { get; set; } 
} 

y puede mantenerlo en marcha. al infinito y más allá !

Answer 3

public class ListOfLists<T> : List<List<T>> 
{ 
} 


var myList = new ListOfLists<string>(); 

Answer 4

He estado jugando con esta idea también, pero estaba tratando de lograr un comportamiento ligeramente diferente. Mi idea era hacer una lista que se heredara a sí misma, creando así una estructura de datos que por naturaleza le permite insertar listas dentro de listas dentro de listas dentro de listas ... ¡infinitamente!

Implementación

//InfiniteList<T> is a list of itself... 
public class InfiniteList<T> : List<InfiniteList<T>> 
{ 
    //This is necessary to allow your lists to store values (of type T). 
    public T Value { set; get; } 
} 

T es un parámetro de tipo genérico. Está ahí para garantizar la seguridad de tipo en su clase. Cuando crea una instancia de InfiniteList, reemplaza T por el tipo con el que desea que se llene su lista, o en este caso, el tipo de la propiedad Value.

Ejemplo

//The InfiniteList.Value property will be of type string 
InfiniteList<string> list = new InfiniteList<string>(); 

Un "trabajo" ejemplo de ello, donde T es en sí misma, una lista de tipo cadena!

//Create an instance of InfiniteList where T is List<string> 
InfiniteList<List<string>> list = new InfiniteList<List<string>>(); 

//Add a new instance of InfiniteList<List<string>> to "list" instance. 
list.Add(new InfiniteList<List<string>>()); 

//access the first element of "list". Access the Value property, and add a new string to it. 
list[0].Value.Add("Hello World"); 

Answer 5

no debe usar Lista anidada en la lista.

List<List<T>> 

no es legal, incluso si T era un tipo definido.

https://msdn.microsoft.com/en-us/library/ms182144.aspx