LINQ एक सूची संपत्ति

Question

के आधार पर इसी मायने रखता है के साथ अलग मैं निम्नलिखित वर्ग

public class Photo 
{ 
    public int Id { get; set; } 
    public string Caption { get; set; } 
    public Collection<string> Tags { get; set; } 
} 

एक तस्वीर के साथ जुड़े कई टैग हो सकता है, और एक ही टैग अलग तस्वीरें के किसी भी संख्या में इस्तेमाल किया जा सकता है।

मैं अंततः जो करना चाहता हूं वह अलग टैग की एक सूची पुनर्प्राप्त करना है, इस बात की गिनती के साथ कि प्रत्येक टैग को कितनी तस्वीरें आवंटित की जाती हैं।

मेरे पास अंतर्निहित डेटा पर कोई नियंत्रण नहीं है - मैं एक एपीआई का उपयोग कर रहा हूं जिसमें एक खोज विधि है जिसका उपयोग मैं फ़ोटो संग्रह को पुनर्प्राप्त करने के लिए कर रहा हूं, लेकिन अलग-अलग टैग की सूची प्राप्त करने के लिए कोई तरीका नहीं है।

तो मेरा सवाल यह है कि, यदि मेरे पास फ़ोटो का एक बड़ा संग्रह है, तो मैं इस सूची में निहित टैग की एक अलग सूची प्राप्त करने के लिए LINQ का उपयोग कैसे कर सकता हूं, और उन टैगों में से प्रत्येक के लिए गिनती (फ़ोटो) प्राप्त कर सकता हूं?

Answer 1

var tagCounts = photos 
    .SelectMany(photo => photo.Tags) 
    .GroupBy(tag => tag, (tag, group) => new { tag, count = group.Count() }) 
    .ToDictionary(tuple => tuple.tag, tuple => tuple.count); 

इस प्रकार तर्क है।

• कई टैग्स के समान टैग प्राप्त होने पर पुनरावृत्ति के साथ सभी टैग का अनुक्रम प्राप्त करें।
• उनके मूल्य से बार-बार टैग समूहित करें, और प्रत्येक समूह में टैग की संख्या गिनें।
• प्रत्येक टैग से एक टैग मैपिंग का निर्माण उस टैग की तस्वीरों की संख्या में करें।

Answer 2

आप इसे दो चरणों में कर सकते हैं।

• पहले अलग टैग के माध्यम से
• दोहराएं सूची से अलग टैग मिलता है और सूची में से गिनती हो और की तरह एक Dictionary<string,int>

कुछ में रख:

List<Photo> list = new List<Photo>(); 
var distinctTags = list.SelectMany(r => r.Tags).Distinct(); 
Dictionary<string, int> dictionary = new Dictionary<string, int>(); 
foreach (string tag in distinctTags) 
{ 
    dictionary.Add(tag, list.Count(r=> r.Tags.Contains(tag))); 
} 

Answer 3

आप उपयोग कर सकते हैं SelectMany & GroupBy इस तरह: -

var result = photos.SelectMany(x => x.Tags, (photosObj, tags) => new {photosObj, tags}) 
        .GroupBy(x => x.tags) 
        .Select(x => new 
         { 
          Tags = x.Key, 
          PhotoId = String.Join(",",x.Select(z => z.photosObj.Id)) 
         }); 

यह आप सभी टैग और उनके संबंधित PhotoIds अल्पविराम में अलग प्रारूप दे देंगे।

अद्यतन:

क्षमा करें, बस noticied आप Photos वस्तु की गिनती करना चाहते हैं, उस मामले में आप बस इस की जरूरत है: -

var result = photos.SelectMany(x => x.Tags) 
        .GroupBy(x => x) 
        .Select(x => new 
           { 
            Tags = x.Key, 
            PhotoCount = x.Count() 
           }); 

तो, मान लीजिए आपके पास यह डेटा: -

List<Photo> photos = new List<Photo> 
{ 
    new Photo { Id =1, Caption = "C1", Tags = new List<string> { "T1", "T2", "T3" }}, 
    new Photo { Id =2, Caption = "C2", Tags = new List<string> { "T4", "T2", "T5" }}, 
    new Photo { Id =3, Caption = "C3", Tags = new List<string> { "T5", "T3", "T2" }} 
}; 

आप उत्पादन नीचे होगा: -

Answer 4

var list=new[]{ 
    new {id=1,Tags=new List<string>{"a","b","c"}}, 
    new {id=2,Tags=new List<string>{"b","c","d"}}, 
    new {id=3,Tags=new List<string>{"c","d","e"}}, 
}; 
var result=list.SelectMany(r=>r.Tags) 
    .GroupBy(r=>r,r=>r,(Key,Vals)=>new {Tag=Key,Count=Vals.Count()}); 

परिणाम:

Tag Count 
a 1 
b 2 
c 3 
d 2 
e 1