2 listes dimensionnelles sont-elles possibles en c#?

, Comme Jon Skeet mentionné que vous pouvez le faire avec un List<Track> à la place. La classe de piste ressemblerait à ceci:

public class Track {
    public int TrackID { get; set; }
    public string Name { get; set; }
    public string Artist { get; set; }
    public string Album { get; set; }
    public int PlayCount { get; set; }
    public int SkipCount { get; set; }
}

Et pour créer une liste de pistes en tant que List<Track>, vous faites simplement ceci:

var trackList = new List<Track>();

Ajouter des pistes peut être aussi simple que ceci:

trackList.add( new Track {
    TrackID = 1234,
    Name = "I'm Gonna Be (500 Miles)",
    Artist = "The Proclaimers",
    Album = "Finest",
    PlayCount = 10,
    SkipCount = 1
});

L'accès aux pistes peut se faire avec l'opérateur d'indexation:

Track firstTrack = trackList[0];

J'espère que cela aide.

C'est le moyen le plus simple que j'ai trouvé pour le faire.

List<List<String>> matrix= new List<List<String>>(); //Creates new nested List
matrix.Add(new List<String>()); //Adds new sub List
matrix[0].Add("2349"); //Add values to the sub List at index 0
matrix[0].Add("The Prime of Your Life");
matrix[0].Add("Daft Punk");
matrix[0].Add("Human After All");
matrix[0].Add("3");
matrix[0].Add("2");

Pour récupérer des valeurs est encore plus facile

string title = matrix[0][1]; //Retrieve value at index 1 from sub List at index 0

Un autre travail autour duquel j'ai utilisé était...

List<int []> itemIDs = new List<int[]>();

itemIDs.Add( new int[2] { 101, 202 } );

La bibliothèque sur laquelle je travaille a une structure de classe très formelle et je n'ai pas voulu de choses supplémentaires pour le privilège d'enregistrer deux entrées "liées".

Repose sur le programmeur entrant seulement un tableau de 2 éléments, mais comme ce n'est pas un élément commun, je pense que cela fonctionne.

Voici comment faire une liste à 2 Dimensions

/ / générer des listes dans une boucle. Liste > biglist = Nouvelle Liste>();

        for(int i = 1; i <= 10; i++)
        {
            List<string> list1 = new List<string>();
            biglist.Add(list1);
        }

        // Populating the lists
        for (int i = 0; i < 10; i++)
        {
            for(int j = 0; j < 10; j++)
            {
                biglist[i].Add((i).ToString() + " " + j.ToString());
            }
        }

        textbox1.Text = biglist[5][9] + "\n";

Soyez conscient du danger d'accéder à un emplacement qui n'est pas peuplé.

Vous pouvez aussi..le faire de cette façon,

List<List<Object>> Parent=new  List<List<Object>>();

List<Object> Child=new List<Object>();
child.Add(2349);
child.Add("Daft Punk");
child.Add("Human");
.
.
Parent.Add(child);

Si vous avez besoin d'un autre article (enfant), créer une nouvelle instance de l'enfant,

Child=new List<Object>();
child.Add(2323);
child.Add("asds");
child.Add("jshds");
.
.
Parent.Add(child);

J'ai utilisé:

List<List<String>> List1 = new List<List<String>>
var List<int> = new List<int>();
List.add("Test");
List.add("Test2");
List1.add(List);
var List<int> = new List<int>();
List.add("Test3");
List1.add(List);

Qui est égal à:

List1
(
[0] => List2 // List1[0][x]
    (
        [0] => Test  // List[0][0] etc.
        [1] => Test2

    )
[1] => List2
    (
        [0] => Test3

Vous pouvez également utiliser DataTable - vous pouvez définir ensuite le nombre de colonnes et leurs types, puis ajouter des lignes http://www.dotnetperls.com/datatable

Voici un petit quelque chose que j'ai fait il y a quelque temps pour un moteur de jeu sur lequel je travaillais. Il a été utilisé comme support de variable d'objet local. Fondamentalement, vous l'utilisez comme une liste normale, mais il détient la valeur à la position de ce que le nom de la chaîne est (ou ID). Un peu de modification, et vous aurez votre liste 2D.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace GameEngineInterpreter
{
    public class VariableList<T>
    {
        private List<string> list1;
        private List<T> list2;

        /// <summary>
        /// Initialize a new Variable List
        /// </summary>
        public VariableList()
        {
            list1 = new List<string>();
            list2 = new List<T>();
        }

        /// <summary>
        /// Set the value of a variable. If the variable does not exist, then it is created
        /// </summary>
        /// <param name="variable">Name or ID of the variable</param>
        /// <param name="value">The value of the variable</param>
        public void Set(string variable, T value)
        {
            if (!list1.Contains(variable))
            {
                list1.Add(variable);
                list2.Add(value);
            }
            else
            {
                list2[list1.IndexOf(variable)] = value;
            }
        }

        /// <summary>
        /// Remove the variable if it exists
        /// </summary>
        /// <param name="variable">Name or ID of the variable</param>
        public void Remove(string variable)
        {
            if (list1.Contains(variable))
            {
                list2.RemoveAt(list1.IndexOf(variable));
                list1.RemoveAt(list1.IndexOf(variable));
            }
        }

        /// <summary>
        /// Clears the variable list
        /// </summary>
        public void Clear()
        {
            list1.Clear();
            list2.Clear();
        }

        /// <summary>
        /// Get the value of the variable if it exists
        /// </summary>
        /// <param name="variable">Name or ID of the variable</param>
        /// <returns>Value</returns>
        public T Get(string variable)
        {
            if (list1.Contains(variable))
            {
                return (list2[list1.IndexOf(variable)]);
            }
            else
            {
                return default(T);
            }
        }

        /// <summary>
        /// Get a string list of all the variables 
        /// </summary>
        /// <returns>List string</string></returns>
        public List<string> GetList()
        {
            return (list1);
        }
    }
}