web-dev-qa-db-fra.com

Des listes bidimensionnelles sont-elles possibles en c #?

Je voudrais mettre en place une liste multidimensionnelle .Pour référence, je travaille sur un analyseur de playlist.

J'ai un fichier/liste de fichiers, que mon programme enregistre dans une liste standard. Une ligne du fichier dans chaque entrée de liste.

J'analyse ensuite la liste à l'aide d'expressions régulières pour trouver des lignes spécifiques ..___ Une partie des données/résultats des lignes doit être placée dans une nouvelle liste multidimensional; comme je ne sais pas combien de résultats/données je vais retrouver, je ne peux pas utiliser un tableau multidimensionnel.

Voici les données que je veux insérer:

Liste des 
 (
 [0] => Liste 
 (
 [0] => ID de piste 
 [1] => Nom 
 [2] => Artiste
 [3] => Album 
 [4] => Nombre de lectures 
 [5] => Nombre de sauts 

) 
 [1] => Liste 
 (
Etc....

Exemple réel:

 Liste 
 (
 [0] => Liste 
 (
 [0] => 2349 
 [1] => Le premier temps de votre vie 
 [2] => Daft Punk 
 [3] => Après tout 
 [4] => 3 
 [5] => 2 

) 
 [1] => Liste
 (

Alors oui, mlist [0] [0] obtiendrait TrackID de la chanson 1, mlist [1] [0] de la chanson 2, etc.

Mais je rencontre d’énormes problèmes lors de la création d’une liste multidimensionnelle. 

List<List<string>> matrix = new List<List<string>>();

Mais je n'ai pas vraiment eu beaucoup plus de progrès :(

c#list
80
CasperT

Et bien vous pouvez utiliser un List<List<string>> où vous écririez ensuite:

List<string> track = new List<string>();
track.Add("2349");
track.Add("The Prime Time of Your Life");
// etc
matrix.Add(track);

Mais pourquoi le feriez-vous au lieu de créer votre propre classe pour représenter une piste, avec les propriétés Track ID, Name, Artist, Album, Play Count et Skip Count? Ensuite, ayez juste un List<Track>.

124
Jon Skeet

Comme Jon Skeet mentionné, vous pouvez le faire avec un List<Track> à la place. La classe de piste ressemblerait à quelque chose comme 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>, procédez comme suit:

var trackList = new List<Track>();

Ajouter des pistes peut être aussi simple que cela:

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 être fait avec l'opérateur d'indexation:

Track firstTrack = trackList[0];

J'espère que cela t'aides.

95
Spoike

C'est la façon la plus simple que j'ai trouvée de 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");

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
32
Jordan LaPrise

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 ne souhaitais pas ajouter de ressources supplémentaires pour pouvoir enregistrer deux contenus «liés».

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

11
paul jamison

Voici comment faire une liste en 2 dimensions

// Génération de listes dans une boucle . Liste> biglist = new 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é.

2
Ben

Vous pouvez aussi ... 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 élément (enfant), créez une nouvelle instance d’enfant,

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

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

cela équivaut à:

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

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

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

0
Val

Voici un petit quelque chose que j'ai créé il y a quelque temps pour un moteur de jeu sur lequel je travaillais. Il a été utilisé en tant que détenteur de variable d'objet local. En gros, vous l'utilisez comme une liste normale, mais la valeur est conservée à l'emplacement de tout nom de chaîne (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);
        }
    }
}
0
Joe Horrell