फ़िल्टर सूची <> ऑब्जेक्ट सी # 2.0

Question

में फ़ोरैच लूप का उपयोग किए बिना ऑब्जेक्ट हम सूची <> में C# में ऑब्जेक्ट को फ़िल्टर कैसे कर सकते हैं?

List<string> myList = new List<string>(); 
myList.Add("hello"); 
myList.Add("world!"); 
myList.Add("one"); 
myList.Add("large!!"); 
List<string> resultList = myList.FindAll(delegate(string s) { return s.Length > 5; }); 

resultList:

Answer 1

मान लीजिए कि हम एक List<string> है और आप केवल आइटम चाहते हैं, जहां स्ट्रिंग की लंबाई से अधिक 5.

है नीचे कोड परिणाम के साथ एक List<string> वापस आ जाएगी चलो दुनिया को दूषित करेगा! और 'बड़ा !!'। यह उदाहरण anonymous method का उपयोग करता है। यह भी लिखा जा सकता है के रूप में:

List<string> myList = new List<string>(); 
// .. 
List<string> resultList = myList.FindAll(OnlyLargerThanFive); 

//.. 

private static bool OnlyLargerThanFive(string s) 
{ 
    return s.Length > 5; 
} 

ऊपर प्रतिनिधि, OnlyLargerThanFive, यह भी एक Predicate कहा जाता है।

Answer 2

@Razzie द्वारा बताए गए तरीके के अलावा आप LINQ का भी उपयोग कर सकते हैं।

List<string> myList = new List<string>(); 
myList.Add("hello"); 
myList.Add("world!"); 
myList.Add("one"); 
myList.Add("large!!"); 

var filtered=from s in myList where s.Length > 5 select s; 

पुनश्च: - नेट 3 में और

Answer 3

ऊपर सबसे अच्छा समाधान लैम्ब्डा उपयोग करने के लिए है ही संभव है:

List<Item> l; 
l.FindAll(n => n.Something == SomethingElse); 

यह आंतरिक रूप से foreach का उपयोग कर सकते हैं, लेकिन आप कर सकते हैं ' पूरी सूची के लिए पुन: प्रयास किए बिना वास्तव में फ़िल्टर करें।

Answer 4

आप LINQ का उपयोग कर सकते हैं। मैं इस परीक्षण नहीं किया है, लेकिन मेरा मानना ​​है कि यह केवल उन है कि एक 'पी' के साथ शुरू दिखाने के लिए पाई भराई की मेरी सूची के तत्वों नीचे फ़िल्टर कर देंगे:

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

list.Add("Apple"); 
list.Add("Peach"); 
list.Add("Chocolate"); 
list.Add("Pear"); 
list.Add("Pumpkin"); 
list.Add("Cherry"); 
list.Add("Coconut"); 


var filteredOnes = from item in list 
        where item.StartsWith("P") 
        select item; 

Answer 5

सूची <> .Find (देता है पहला मिलान मौका) और List.FindAll() सभी मिलान अवसरों देता है। होगा जटिल प्रकार की एक सूची के साथ एक उदाहरण के रूप में अनुवर्ती है:

मैं एक वर्ग की रिपोर्ट:

public class Report 
{ 
    public string ReportName; 
    public ReportColumnList ReportColumnList; 
} 

और

List<Report> reportList; 

रिपोर्ट

की एक सूची सूची जहां में आइटम ढूंढने के लिए ReportName = 'MyReport', कोड होगा:

string reportName = "MyReport"; 
List<Report> myReports = reportList.FindAll(delegate(Report obj) { return obj.ReportName == reportName; }); 

पहली रिपोर्ट प्राप्त करने के लिए :

Report rc = reportList.Find(delegate(Report obj) { return obj.ReportName == reportName; }); 

ध्यान दें कि वस्तु प्रतिनिधि के लिए पारित प्रकार जिसके साथ सूची से भर जाता है की होना चाहिए।

Answer 6

आप इस तरह LINQ का उपयोग कर सकते हैं।

List<string> List = new List<string> { "i", "am", "using", "LINQ!" }; List<string> result = myList.Where(s => s.Length > 3).ToList();

यह केवल .net 3 और इसके बाद के संस्करण में काम कर रहा है।