Listas bidimensionais são possíveis em c #?

Eu gostaria de criar uma lista multidimensional. Para referência, estou trabalhando em um analisador de lista de reprodução.

Eu tenho um arquivo / lista de arquivos, que meu programa salva em uma lista padrão. Uma linha do arquivo em cada entrada da lista.

Em seguida, analiso a lista com expressões regulares para encontrar linhas específicas. Alguns dos dados / resultados das linhas precisam ser colocados em uma nova lista multidimensional ; como não sei com quantos resultados / dados vou acabar, não posso usar um array multidimensional.

Aqui estão os dados que desejo inserir:

Lista
(
    [0] => Lista
        (
            [0] => ID da faixa
            [1] => Nome
            [2] => Artista
            [3] => Álbum
            [4] => Contagem de reprodução
            [5] => Contagem de pulos

        )
    [1] => Lista
        (
E assim por diante....

Exemplo real:

Lista
(
    [0] => Lista
        (
            [0] => 2349
            [1] => O melhor momento da sua vida
            [2] => Daft Punk
            [3] => Humano Afinal
            [4] => 3
            [5] => 2

        )
    [1] => Lista
        (

Então, sim, mlist [0] [0] obteria TrackID da música 1, mlist [1] [0] da música 2 etc.

Mas estou tendo grandes problemas para criar uma lista multidimensional. Até agora eu vim com

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

Mas eu realmente não tive muito progresso :(

Bem, você certamente pode usar um List<List<string>>onde escreveria:

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

Mas por que você faria isso em vez de criar sua própria classe para representar uma faixa, com as propriedades Track ID, Name, Artist, Album, Play Count e Skip Count? Então é só tomar um List<Track>.

Como Jon Skeet mencionou, você pode fazer isso com um List<Track>. A classe Track seria mais ou menos assim:

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

E para criar uma lista de trilhas como um, List<Track>basta fazer o seguinte:

var trackList = new List<Track>();

Adicionar faixas pode ser tão simples quanto isto:

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

O acesso às faixas pode ser feito com o operador de indexação:

Track firstTrack = trackList[0];

Espero que isto ajude.

Esta é a maneira mais fácil que encontrei de fazer isso.

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

Recuperar valores é ainda mais fácil

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

outro trabalho em torno do qual usei foi ...

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

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

A biblioteca na qual estou trabalhando tem uma estrutura de classes muito formal e eu não queria material extra lá para ter o privilégio de gravar dois ints 'relacionados'.

Depende do programador inserir apenas uma matriz de 2 itens, mas como não é um item comum, acho que funciona.

Você também pode ... fazer desta forma,

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

se você precisar de outro item (filho), crie uma nova instância de filho,

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

Aqui está como fazer uma lista bidimensional

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

Esteja ciente do perigo de acessar um local não povoado.

Eu usei:

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

isso é igual a:

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

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

Você também pode usar DataTable - você pode definir o número de colunas e seus tipos e, em seguida, adicionar linhas http://www.dotnetperls.com/datatable

Aqui está uma coisinha que fiz um tempo atrás para um motor de jogo em que estava trabalhando. Foi usado como um portador de variável de objeto local. Basicamente, você a usa como uma lista normal, mas ela mantém o valor na posição do nome da string (ou ID). Uma pequena modificação e você terá sua lista 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);
        }
    }
}