क्या ग # में 2 आयामी सूचियाँ संभव हैं?

Question 1

मैं एक बहुआयामी सूची स्थापित करना चाहता हूं। संदर्भ के लिए, मैं एक प्लेलिस्ट विश्लेषक पर काम कर रहा हूं।

मेरे पास एक फ़ाइल / फ़ाइल-सूची है, जो मेरा कार्यक्रम एक मानक सूची में बचाता है। प्रत्येक सूची प्रविष्टि में फ़ाइल से एक पंक्ति।

फिर मैं विशिष्ट लाइनों को खोजने के लिए नियमित-अभिव्यक्तियों के साथ सूची का विश्लेषण करता हूं। लाइनों से कुछ डेटा / परिणाम को एक नई बहुआयामी सूची में डालने की आवश्यकता है ; चूंकि मुझे नहीं पता कि मैं कितने परिणाम / डेटा समाप्त करूंगा, इसलिए मैं एक बहुआयामी सरणी का उपयोग नहीं कर सकता।

यहां वह डेटा है जिसे मैं सम्मिलित करना चाहता हूं:

सूची
(
    [०] => सूची
        (
            [०] => ट्रैक आईडी
            [१] => नाम
            [२] => कलाकार
            [३] => एल्बम
            [४] => खेलने की गिनती
            [५] => गणना छोड़ें

        )
    [१] => सूची
        (
और इसी तरह....

वास्तविक उदाहरण:

सूची
(
    [०] => सूची
        (
            [०] => २३४ ९
            [१] => आपके जीवन का प्रमुख समय
            [२] => डफ़्ट पंक
            [३] => मानव आफ्टर ऑल
            [४] => ३
            [५] => २

        )
    [१] => सूची
        (

तो हाँ, mlist [0] [0] गीत 1 से ट्रैकआईडी मिलेगा, गीत 1 से mlist [1] [0] आदि।

लेकिन मुझे एक बहुआयामी सूची बनाने में बहुत बड़ी समस्याएँ हैं। अब तक मैं साथ आता रहा हूं

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

लेकिन मैं वास्तव में बहुत अधिक प्रगति नहीं किया है :(

Question 2

ठीक है आप निश्चित रूप से उपयोग कर सकते हैं List<List<string>>जहाँ आप फिर लिखेंगे:

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

लेकिन आप ट्रैक आईडी, नाम, कलाकार, एल्बम, प्ले काउंट और स्किप प्रॉपर्टी के साथ ट्रैक का प्रतिनिधित्व करने के लिए अपनी खुद की क्लास बनाने के बजाय ऐसा क्यों करेंगे? तो बस एक है List<Track>।

Question 3

जैसा कि जॉन स्कीट ने उल्लेख किया है कि आप List<Track>इसके बजाय कर सकते हैं । ट्रैक वर्ग कुछ इस तरह दिखाई देगा:

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

और एक ट्रैक सूची बनाने के लिए जैसा कि List<Track>आप बस ऐसा करते हैं:

var trackList = new List<Track>();

पटरियों को जोड़ना इस प्रकार सरल हो सकता है:

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

अनुक्रमण ऑपरेटर के साथ एक्सेसिंग ट्रैक किया जा सकता है:

Track firstTrack = trackList[0];

उम्मीद है की यह मदद करेगा।

Question 4

यह ऐसा करने का सबसे आसान तरीका है।

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

मूल्यों को पुनः प्राप्त करना और भी आसान है

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

Question 5

एक और काम जिसके इर्द-गिर्द मैंने काम किया था ...

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

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

जिस लाइब्रेरी में मैं काम कर रहा हूं, उसके पास एक बहुत ही औपचारिक वर्ग संरचना है और मैंने दो 'संबंधित' इन्टर्स को रिकॉर्ड करने के विशेषाधिकार के लिए वहां प्रभावी रूप से अतिरिक्त सामान नहीं रखा।

प्रोग्रामर पर निर्भर करता है कि वह केवल 2 आइटम ऐरे में प्रवेश करे लेकिन जैसा कि यह एक सामान्य आइटम नहीं है मुझे लगता है कि यह काम करता है।

Question 6

आप इस तरह से भी कर सकते हैं।

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

यदि आपको किसी अन्य आइटम (बच्चे) की आवश्यकता है, तो बच्चे का एक नया उदाहरण बनाएं,

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

Question 7

यहाँ 2 आयामी सूची बनाने का तरीका बताया गया है

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

किसी ऐसे स्थान पर पहुंचने के खतरे से अवगत रहें, जो आबाद नहीं है।

Question 8

मैंनें इस्तेमाल किया:

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

बराबर है:

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

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

Question 9

आप DataTable का उपयोग भी कर सकते हैं - फिर आप स्तंभों की संख्या और उनके प्रकारों को परिभाषित कर सकते हैं और फिर पंक्तियाँ जोड़ सकते हैं http://www.dotnetperls.com/datable

Question 10

यहाँ एक छोटी सी चीज है जिसे मैंने कुछ समय पहले एक गेम इंजन के लिए बनाया था जिस पर मैं काम कर रहा था। इसका उपयोग स्थानीय वस्तु चर धारक के रूप में किया जाता था। मूल रूप से, आप इसे एक सामान्य सूची के रूप में उपयोग करते हैं, लेकिन यह उस स्थिति में मूल्य रखता है जो कभी स्ट्रिंग नाम (या आईडी) है। थोड़ा सा संशोधन, और आपके पास अपनी 2 डी सूची होगी।

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