ऑब्जेक्ट्स के लिए LINQ का उपयोग करना और एक विशिष्ट संपत्ति को छोड़कर

Question

जब मेरे पास 2 List<string> ऑब्जेक्ट्स हैं, तो मैं और Except का उपयोग सीधे आउटपुट IEnumerable<string> प्राप्त करने के लिए कर सकता हूं। यह काफी आसान है, लेकिन अगर मैं कुछ जटिल पर छेड़छाड़/विघटन करना चाहता हूं तो क्या होगा?

उदाहरण के लिए, ClassA वस्तुओं, जिस पर एक दूसरे को काटना का परिणाम है का एक संग्रह प्राप्त करने की कोशिश ClassA वस्तु की AStr1 और ClassB वस्तु की BStr; :

public class ClassA { 
    public string AStr1 { get; set; } 
    public string AStr2 { get; set; } 
    public int AInt { get; set; } 
} 
public class ClassB { 
    public string BStr { get; set; } 
    public int BInt { get; set; } 
} 
public class Whatever { 
    public void xyz(List<ClassA> aObj, List<ClassB> bObj) { 
     // *** this line is horribly incorrect *** 
     IEnumberable<ClassA> result = 
      aObj.Intersect(bObj).Where(a, b => a.AStr1 == b.BStr); 
    } 
} 

मैं इस चौराहे को प्राप्त करने के लिए नोटलाइन लाइन को कैसे ठीक कर सकता हूं।

Answer 1

MoreLINQExceptBy है। यह अभी तक IntersectBy नहीं है, लेकिन आप आसानी से अपने खुद के कार्यान्वयन लिख सकता है, और संभवतः MoreLINQ करने के लिए इसे बाद में योगदान :)

यह शायद कुछ इस तरह (छोड़ते हुए त्रुटि जाँच) दिखेगा:

public static IEnumerable<TSource> IntersectBy<TSource, TKey>(
    this IEnumerable<TSource> first, 
    IEnumerable<TSource> second, 
    Func<TSource, TKey> keySelector, 
    IEqualityComparer<TKey> keyComparer) 
{ 
    HashSet<TKey> keys = new HashSet<TKey>(first.Select(keySelector), 
              keyComparer); 
    foreach (var element in second) 
    { 
     TKey key = keySelector(element); 
     // Remove the key so we only yield once 
     if (keys.Remove(key)) 
     { 
      yield return element; 
     } 
    } 
} 

यदि आप एक सामान्य संपत्ति प्रकार के दो अलग-अलग प्रकारों पर एक छेड़छाड़ करना चाहते हैं, तो आप तीन प्रकार के पैरामीटर (first के लिए एक, second के लिए एक और सामान्य कुंजी के लिए एक और सामान्य विधि बना सकते हैं) प्रकार)।

Answer 2

एक्स ∈ ए ∩ बी यदि और केवल यदि एक्स ∈ एक और एक्स ∈ बी

तो, aObj में प्रत्येक a के लिए, आप देख सकते हैं कि a.AStr1BStr मूल्यों के दस्तावेज़ में है।

public void xyz(List<ClassA> aObj, List<ClassB> bObj) 
{ 
    HashSet<string> bstr = new HashSet<string>(bObj.Select(b => b.BStr)); 
    IEnumerable<ClassA> result = aObj.Where(a => bstr.Contains(a.AStr1)); 
} 

Answer 3

इस कोड:

[TestMethod] 
    public void PropertyIntersectionBasedJoin() 
    { 
     List<ClassA> aObj = new List<ClassA>() 
           { 
            new ClassA() { AStr1 = "a" }, 
            new ClassA() { AStr1 = "b" }, 
            new ClassA() { AStr1 = "c" } 
           }; 
     List<ClassB> bObj = new List<ClassB>() 
           { 
            new ClassB() { BStr = "b" }, 
            new ClassB() { BStr = "b" }, 
            new ClassB() { BStr = "c" }, 
            new ClassB() { BStr = "d" } 
           }; 

     var result = xyz(aObj, bObj); 

     Assert.AreEqual(2, result.Count()); 
     Assert.IsFalse(result.Any(a => a.AStr1 == "a")); 
     Assert.IsTrue(result.Any(a => a.AStr1 == "b")); 
     Assert.IsTrue(result.Any(a => a.AStr1 == "c")); 
    }