Zijn 2-dimensionale lijsten mogelijk in c#?

Ik wil graag een multidimensionale lijst maken.
Ter referentie, ik werk aan een afspeellijstanalysator.

Ik heb een bestand/bestandslijst, die mijn programma opslaat in een standaardlijst. Eén regel uit het bestand in elk lijstitem.

Vervolgens analyseer ik de lijst met reguliere expressies om specifieke regels te vinden.
Sommige gegevens/resultaten van de regels moeten in een nieuwe multidimensionalelijst worden geplaatst; aangezien ik niet weet met hoeveel resultaten/gegevens ik zal eindigen, kan ik geen multidimensionale array gebruiken.

Dit zijn de gegevens die ik wil invoegen:

Lijst
(
  [0] => Lijst
    (
      [0] => Track-id
      [1] => Naam
      [2] => Artiest
      [3] => Album
      [4] => Speel Telling
      [5] => Telling overslaan
    )
  [1] => Lijst
    (
Enzovoort....

Echt voorbeeld:

Lijst
(
  [0] => Lijst
    (
      [0] => 2349
      [1] => De prime time van je leven
      [2] => Daft Punk
      [3] => Toch menselijk
      [4] => 3
      [5] => 2
    )
  [1] => Lijst
    (

Dus ja, mlist[0][0] zou TrackID krijgen van nummer 1, mlist[1][0] van nummer 2 enz.

Maar ik heb grote problemen met het maken van een multidimensionale lijst.
Tot nu toe heb ik bedacht

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

Maar ik heb niet echt veel vooruitgang geboekt 🙁


Antwoord 1, autoriteit 100%

Nou, je kun je zekereen List<List<string>>gebruiken waar je dan zou kunnen schrijven:

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

Maar waarom zou je dat doen in plaats van je eigen klasse te bouwen om een ​​nummer te vertegenwoordigen, met eigenschappen voor track-ID, naam, artiest, album, Play Count en Skip Count? Dan heb je gewoon een List<Track>.


Antwoord 2, autoriteit 72%

Zoals Jon Skeetal zei, kun je het doen met een List<Track>in plaats daarvan. De Track-klasse zou er ongeveer zo uitzien:

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

En om een ​​tracklijst te maken als een List<Track>doe je gewoon dit:

var trackList = new List<Track>();

Tracks toevoegen kan zo simpel zijn:

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

Toegang tot tracks kan worden gedaan met de indexeringsoperator:

Track firstTrack = trackList[0];

Hopelijk helpt dit.


Antwoord 3, autoriteit 24%

Dit is de gemakkelijkste manier die ik heb gevonden om het te doen.

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

Waarden ophalen is nog makkelijker

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

Antwoord 4, autoriteit 9%

een ander werk dat ik heb gebruikt was…

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

De bibliotheek waar ik aan werk heeft een zeer formele klassenstructuur en ik wilde er geen extra spullen in hebben voor het voorrecht om twee ‘gerelateerde’ ints op te nemen.

Vertrouwt erop dat de programmeur slechts een array van 2 items invoert, maar omdat het geen algemeen item is, denk ik dat het werkt.


Antwoord 5

Je kunt ook..op deze manier doen,

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

als je een ander artikel nodig hebt (kind),
maak een nieuwe instantie van kind,

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

Antwoord 6

Hier leest u hoe u een tweedimensionale lijst maakt

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

Wees je bewust van het gevaar van toegang tot een locatie die niet bevolkt is.


Antwoord 7

Ik gebruikte:

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

dat is gelijk aan:

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

Antwoord 8

U kunt ook DataTable gebruiken – u kunt vervolgens het aantal kolommen en hun typen definiëren en vervolgens rijen toevoegen
http://www.dotnetperls.com/datatable


Antwoord 9

Hier is iets dat ik een tijdje geleden heb gemaakt voor een game-engine waar ik aan werkte. Het werd gebruikt als een lokale objectvariabele houder. In principe gebruik je het als een normale lijst, maar het bevat de waarde op de positie van wat de stringnaam ook is (of ID). Een beetje aanpassen en je hebt je 2D-lijst.

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

Antwoord 10

Omdat het nog niet genoemd is, geef ik soms de voorkeur aan een List<Dictionary<string, string>>. Er zijn gevallen waarin ik om wat voor reden dan ook gewoon geen aangepast object wil maken, en deze supereenvoudige gegevensstructuur is behoorlijk flexibel. Ik realiseer me dat alles een string is die inefficiënt is, en het dwingt je om te ontleden en te stringificeren bij het verhogen van de PlayCount, maar voor sommige mensen kan het de moeite waard zijn.

var trackList = new List<Dictionary<string, string>>();
var track = new Dictionary<string, string>();
track.Add("TrackID"  , "1234");
track.Add("Name"     , "I'm Gonna Be (500 Miles)");
track.Add("Artist"   , "The Proclaimers");
track.Add("Album"    , "Finest");
track.Add("PlayCount", "10");
track.Add("SkipCount", "1");
trackList.Add(track);

Dit heeft eigenlijk een aantal voordelen ten opzichte van een aangepast object, namelijk dat je een nieuwe sleutelwaarde aan sommige van de sporen kunt toevoegen, zonder dat je deze aan alle sporen hoeft toe te voegen, en de bestaande code zal nog steeds werken zonder opnieuw te compileren. Het is duidelijk dat je opnieuw moet compileren als je code schrijft om iets met die nieuwe sleutels te doen, maar het is niet vereist. Ten tweede, als je de gegevens ooit in een bestand opslaat, wil je waarschijnlijk dat het leesbaar is voor mensen (ik zou dat doen), in welk geval het sowieso allemaal strings zijn. U kunt sleutels of waarden toevoegen, verwijderen of wijzigen met een teksteditor en deze gegevensstructuur kan dit aan.

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Other episodes