सी # में एक सूची में एकाधिक पैरा। कक्षा के बिना कैसे बनाया जाए?

Question

यह शायद एक सुंदर स्पष्ट सवाल है, लेकिन मैं List बनाने के बारे में कैसे जाउंगा जिसमें कक्षा बनाने के बिना कई पैरामीटर हैं।

उदाहरण:

var list = new List<string, int>(); 

list.Add("hello", 1); 

मैं सामान्य रूप से तो जैसे एक वर्ग का प्रयोग करेंगे:

public class MyClass 
{ 
    public String myString {get; set;} 
    public Int32 myInt32 {get; set;} 
} 

तो ऐसा करके मेरी सूची बनाने के लिए:

var list = new List<MyClass>(); 
list.Add(new MyClass { myString = "hello", myInt32 = 1 }); 

Answer 1

आप .NET 4.0 उपयोग कर रहे हैं आप Tuple का उपयोग कर सकते हैं।

List<Tuple<T1, T2>> list; 

नेट आप एक कस्टम वर्ग बनाने के लिए (जब तक आप भाग्यशाली एक वर्ग है कि आधार वर्ग पुस्तकालय में अपनी आवश्यकताओं फिट बैठता है खोजने के लिए सक्षम होने के लिए कर रहे हैं) है के पुराने संस्करणों के लिए

।

Answer 2

आप आइटम कोई आपत्ति नहीं है किया जा रहा है imutable आप उपयोग कर सकते Tuple वर्ग 4

var list = new List<Tuple<string,int>>(); 
list.Add(new Tuple<string,int>("hello", 1)); 

list[0].Item1 //Hello 
list[0].Item2 //1 

शुद्ध करने के लिए लेकिन अगर आप हर बार दो आइटम जोड़ रहे हैं जोड़ा गया है और उनमें से एक विशिष्ट आईडी का उपयोग कर सकते है Dictionary

Answer 3

सूची केवल एक प्रकार पैरामीटर स्वीकार करती है। निकटतम आप सूची के साथ मिलेगा:

var list = new List<Tuple<string, int>>(); 
list.Add(Tuple.Create("hello", 1)); 

Answer 4

उचित हैं, तो आप एक शब्दकोश जो भी एक सामान्य संग्रह है का उपयोग हो सकता है:

Dictionary<string, int> d = new Dictionary<string, int>(); 
d.Add("string", 1); 

Answer 5

स्कॉट चेम्बरलेन (और कई अन्य) के कहे अनुसार , यदि आप अपरिवर्तनीय (यानी केवल पढ़ने के लिए) वस्तुओं को ध्यान में रखते हैं तो टुपल्स सबसे अच्छा काम करते हैं।

, तो दाऊद ने सुझाव दिया की तरह, आप स्ट्रिंग मान द्वारा पूर्णांक संदर्भ लेना चाहते हैं, उदाहरण के लिए, आप एक शब्दकोश

Dictionary<string, int> d = new Dictionary<string, int>(); 
d.Add("string", 1); 
Console.WriteLine(d["string"]);//prints 1 

अगर, हालांकि, आप एक में mutably अपने तत्वों को संग्रहीत करना चाहते हैं का उपयोग करना चाहिए

var kvp=new KeyValuePair<int, string>(2, "a"); 
//kvp.Key=2 and a.Value="a"; 
kvp.Key = 3;//both key and 
kvp.Value = "b";//value are mutable 

: सूची, और एक शब्दकोश शैली संदर्भित प्रणाली, तो आपका सर्वश्रेष्ठ दांव (यानी केवल वास्तविक समाधान अभी) का उपयोग किया जाएगा KeyValuePair है, जो अनिवार्य है std :: सी # के लिए जोड़ी का उपयोग नहीं करना चाहते हैं

बेशक, यह स्टैकेबल है, इसलिए यदि आपको एक बड़ा टुपल चाहिए (जैसे कि आपको 4 एल की आवश्यकता है ements) आप बस इसे ढेर। दी इस बदसूरत वास्तव में तेजी से हो जाता है:

 var quad=new KeyValuePair<KeyValuePair<int,string>, KeyValuePair<int,string>> 
       (new KeyValuePair<int,string>(3,"a"), 
       new KeyValuePair<int,string>(4,"b")); 
//quad.Key.Key=3 

तो जाहिर है, अगर आप ऐसा करने के लिए गए थे, तो आप शायद यह भी एक सहायक समारोह परिभाषित करना चाहिए।

मेरी सलाह यह है कि यदि आपके ट्यूपल में 2 से अधिक तत्व होते हैं, तो अपनी कक्षा को परिभाषित करें। आप की तरह बयान का उपयोग कर एक typedef-esque इस्तेमाल कर सकते हैं:

using quad = KeyValuePair<KeyValuePair<int,string>, KeyValuePair<int,string>>; 

लेकिन वह अपने instantiations आसान नहीं पड़ता है।यदि आप 2 से अधिक तत्वों के tuples के साथ काम करते समय उपयोगकर्ता परिभाषित वर्ग के साथ जाते हैं तो आप टेम्पलेट पैरामीटर और अधिक समय में गैर-बॉयलरप्लेट कोड पर अधिक समय व्यतीत करेंगे

Answer 6

अन्य सुझाए गए सुझावों को जोड़ने के लिए keyvaluepair संग्रह में सदस्यों को जोड़ने की परेशानी से बचने के लिए निम्नलिखित निर्माण की तरह।

public class KeyValuePairList<Tkey,TValue> : List<KeyValuePair<Tkey,TValue>>{ 
    public void Add(Tkey key, TValue value){ 
     base.Add(new KeyValuePair<Tkey, TValue>(key, value)); 
    } 
} 

इसका मतलब क्या है कि निर्माता बेहतर वाक्य रचना ::

var myList = new KeyValuePairList<int,string>{{1,"one"},{2,"two"},{3,"three"}}; 

मैं व्यक्तिगत रूप से ऊपर कोड अधिक वर्बोज़ उदाहरणों पर दुर्भाग्य से सी # वास्तव में टपल प्रकार मूल रूप से तो समर्थन नहीं करता साथ प्रारंभ किया जा सकता है यह छोटा हैक अद्भुत काम करता है।

यदि आपको खुद को वास्तव में 2 से अधिक की आवश्यकता है, तो मैं सुझाव देता हूं कि टुपल प्रकार के खिलाफ abstractions बनाना। (हालांकि Tuple एक वर्ग नहीं है जैसे KeyValuePair यह एक दिलचस्प भेद है)।

उत्सुकता से पर्याप्त, प्रारंभकर्ता सूची वाक्यविन्यास किसी भी IEnumerable पर उपलब्ध है और यह आपको Add विधि का उपयोग करने की अनुमति देता है, यहां तक ​​कि वे वास्तव में आपके ऑब्जेक्ट द्वारा गणना नहीं करते हैं। यह object[] सदस्य params object[] सदस्य के रूप में जोड़ने जैसी चीज़ों को अनुमति देने के लिए बहुत आसान है।

Answer 7

यह मेरे साथ ठीक

List<string> myList = new List<string>(); 
myList.Add(string.Format("{0}|{1}","hello","1") ; 


label:myList[0].split('|')[0] 
val: myList[0].split('|')[1] 

Answer 8

एक कक्षा का उपयोग करने के चाहने वालों के लिए काम करता है।

सभी मापदंडों के साथ एक कक्षा बनाएं आप चाहते हैं

पैरामीटर

class MyClass 
 
     { 
 
      public string S1; 
 
      public string S2; 
 
     } 
 

 
List<MyClass> MyList= new List<MyClass>();

Answer 9

एक अन्य समाधान गुमनाम प्रकार के सामान्य सूची बनाने के रूप में वर्ग के साथ एक सूची बनाएं।

var list = new[] 
{ 
    new { Number = 10, Name = "Smith" }, 
    new { Number = 10, Name = "John" } 
}.ToList(); 

foreach (var item in list) 
{ 
    Console.WriteLine(item.Name); 
} 

यह भी आप intellisense समर्थन देता है, मैं कुछ स्थितियों में लगता है कि अपने Tuple और Dictionary की तुलना में बेहतर।

Answer 10

डेटाबेस से स्कीमा नाम और तालिका का नाम प्राप्त करें।

 public IList<Tuple<string, string>> ListTables() 
     { 

      DataTable dt = con.GetSchema("Tables"); 

      var tables = new List<Tuple<string, string>>(); 

      foreach (DataRow row in dt.Rows) 
      { 
      string schemaName = (string)row[1]; 
      string tableName = (string)row[2]; 
      //AddToList(); 
      tables.Add(Tuple.Create(schemaName, tableName)); 
      Console.WriteLine(schemaName +" " + tableName) ; 
      } 
      return tables; 
     }