web-dev-qa-db-fra.com

Créer une liste de listes en C #

Il me semble avoir du mal à comprendre l'idée d'une liste générique de listes génériques en C #. Je pense que le problème provient de l'utilisation de l'argument <T>, avec lequel je n'ai aucune expérience préalable. Quelqu'un pourrait-il fournir un court exemple de déclaration d'une classe qui est une liste, qui contient une autre liste, mais où le type de l'objet qu'il contient n'est pas immédiatement connu?

J'ai lu la documentation de MS sur Generics et je ne suis pas tout à fait sûr de pouvoir déclarer un List<List<T>>, ni comment passer exactement le paramètre <T> à la liste intérieure.

Edit: Ajout d'informations

Est-ce que déclarer un List<List<T>> serait considéré comme légal ici? Au cas où vous vous le demanderiez, je construis une classe qui me permet d’utiliser un ulong en tant qu’indexeur et (avec un peu de chance) contourne la vilaine limite de 2 Go de .Net en maintenant une liste de listes. 

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>>();
        }
c#.net
39
user978122

Un exemple rapide:

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);
    }
}

Est-ce ce que vous cherchiez? Ou essayez-vous de créer une nouvelle variable class qui étend List<T> et dont le membre est une "liste"?

69
Gromer

ou cet exemple, juste pour le rendre plus visible:

public class CustomerListList : List<CustomerList> { }  

public class CustomerList : List<Customer> { }

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

et vous pouvez le garder. A l'infini et au-delà !

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


var myList = new ListOfLists<string>();
2
Michael Christensen

J'ai aussi joué avec cette idée, mais j'essayais d'obtenir un comportement légèrement différent. Mon idée était de faire une liste qui hérite d'elle-même, créant ainsi une structure de données qui, par nature, vous permet d'intégrer des listes dans des listes dans des listes dans des listes ... à l'infini!

La mise en oeuvre 

//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 est un paramètre de type générique. Il est là pour assurer la sécurité de type dans votre classe. Lorsque vous créez une instance de InfiniteList, vous remplacez T par le type de votre liste ou, dans ce cas, par le type de la propriété Value.

Exemple 

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

Un exemple "de travail" de ceci, où T est en soi, une liste de type string!

//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");
1
series0ne

vous ne devez pas utiliser la liste imbriquée dans la liste.

List<List<T>>

n'est pas légal, même si T était un type défini.

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

0
freakydinde