Sind zweidimensionale Listen in c # möglich?

Ich möchte eine mehrdimensionale Liste erstellen. Als Referenz arbeite ich an einem Playlist-Analysator.

Ich habe eine Datei / Dateiliste, die mein Programm in einer Standardliste speichert. Eine Zeile aus der Datei in jedem Listeneintrag.

Ich analysiere dann die Liste mit regulären Ausdrücken, um bestimmte Zeilen zu finden. Einige der Daten / Ergebnisse aus den Zeilen müssen in eine neue mehrdimensionale Liste aufgenommen werden. Da ich nicht weiß, mit wie vielen Ergebnissen / Daten ich enden werde, kann ich kein mehrdimensionales Array verwenden.

Hier sind die Daten, die ich einfügen möchte:

Aufführen
(
    [0] => Liste
        (
            [0] => Track ID
            [1] => Name
            [2] => Künstler
            [3] => Album
            [4] => Anzahl spielen
            [5] => Anzahl überspringen

        )
    [1] => Liste
        (
Und so weiter....

Echtes Beispiel:

Aufführen
(
    [0] => Liste
        (
            [0] => 2349
            [1] => Die Hauptzeit deines Lebens
            [2] => Daft Punk
            [3] => Immerhin ein Mensch
            [4] => 3
            [5] => 2

        )
    [1] => Liste
        (

Also ja, mlist [0] [0] würde TrackID von Song 1, mlist [1] [0] von Song 2 usw. erhalten.

Aber ich habe große Probleme beim Erstellen einer mehrdimensionalen Liste. Bisher habe ich mir ausgedacht

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

Aber ich habe nicht wirklich viel mehr Fortschritte gemacht :(

Nun haben Sie sicher kann verwenden ein List<List<string>>, man würde dann schreiben:

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

Aber warum sollten Sie das tun, anstatt eine eigene Klasse zu erstellen, die einen Titel mit den Eigenschaften Titel-ID, Name, Künstler, Album, Wiedergabezahl und Überspringzahl darstellt? Dann haben Sie einfach eine List<Track>.

Wie Jon Skeet bereits erwähnt hat, können Sie dies List<Track>stattdessen mit einem tun . Die Track-Klasse würde ungefähr so ​​aussehen:

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

Und um eine Titelliste zu erstellen, List<Track>tun Sie einfach Folgendes:

var trackList = new List<Track>();

Das Hinzufügen von Tracks kann so einfach sein:

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

Der Zugriff auf Tracks kann mit dem Indexierungsoperator erfolgen:

Track firstTrack = trackList[0];

Hoffe das hilft.

Dies ist der einfachste Weg, den ich gefunden habe, um es zu tun.

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

Das Abrufen von Werten ist noch einfacher

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

Eine andere Arbeit, die ich verwendet habe, war ...

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

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

Die Bibliothek, an der ich arbeite, hat eine sehr formale Klassenstruktur und ich wollte dort keine zusätzlichen Dinge für das Privileg, zwei "verwandte" Ints aufzunehmen.

Verlässt sich darauf, dass der Programmierer nur ein Array mit 2 Elementen eingibt, aber da es kein allgemeines Element ist, denke ich, dass es funktioniert.

Sie können auch ... auf diese Weise tun,

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

Wenn Sie ein anderes Element (untergeordnetes Element) benötigen, erstellen Sie eine neue Instanz von untergeordnetem Element.

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

Hier erfahren Sie, wie Sie eine zweidimensionale Liste erstellen

        // Generating lists in a loop.
        List<List<string>> biglist = new List<List<string>>();

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

Seien Sie sich der Gefahr bewusst, auf einen Ort zuzugreifen, der nicht besiedelt ist.

Ich benutzte:

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

das entspricht:

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

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

Sie können auch DataTable verwenden - Sie können dann die Anzahl der Spalten und ihre Typen definieren und dann Zeilen hinzufügen http://www.dotnetperls.com/datatable

Hier ist etwas, das ich vor einiger Zeit für eine Spiel-Engine gemacht habe, an der ich gearbeitet habe. Es wurde als lokaler Objektvariablenhalter verwendet. Grundsätzlich verwenden Sie es als normale Liste, aber es enthält den Wert an der Position des Zeichenfolgennamens (oder der ID). Ein bisschen Modifikation, und Sie haben Ihre 2D-Liste.

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