समेकित समझने में सहायता करें। जॉइन विधि

Question

कल मैं posted this question एक जॉइन() विधि के अंदर लैम्बडास का उपयोग करने के संबंध में यह जांचने के लिए कि 2 इकाइयों में 2 स्थितियां मौजूद हैं या नहीं। मुझे इस सवाल पर एक जवाब मिला, जिसने पूरी तरह से काम किया। मैंने अनुमान लगाया कि एमएसडीएन आलेख को Enumerable.Join() विधि पर पढ़ने के बाद, मैं समझूंगा कि वास्तव में क्या हो रहा था, लेकिन मैं नहीं करता। क्या कोई मुझे समझने में मदद कर सकता है कि नीचे दिए गए कोड में क्या चल रहा है (विशेष रूप से शामिल हों) विधि? अग्रिम में धन्यवाद।

if (db.TableA.Where(a => a.UserID == currentUser) 
     .Join(db.TableB.Where(b => b.MyField == someValue), 
      o => o.someFieldID, 
      i => i.someFieldID, 
      (o,i) => o) 
     .Any()) 
{ 
    //... 
} 

संपादित करें: विशेष रूप से, मैं पिछले 3 पैरामीटर के बारे में उत्सुक हूँ, और क्या वास्तव में हो रहा है। वे समारोह (TOuter, TKey), समारोह (टिन से मढ़नेवाला, TKey) आदि

Answer 1

एरिक और निक दोनों ने अच्छे उत्तर दिए हैं।

आप क्वेरी वाक्यविन्यास का उपयोग कर लिंक क्वेरी अभिव्यक्ति भी लिख सकते हैं (बनाम।विधि वाक्य रचना, जो आप अपने उदाहरण में उपयोग कर रहे हैं):

var query = from a in db.TableA 
      join b in db.TableB on a.someFieldID equals b.someFieldID 
      where a.UserID == currentUser && b.MyField == someValue 
      select a; 

     if (query.Any()) { 
      ... 
     } 

अद्यतन:

आप लग लैम्ब्डा भाव पर अटक जाना है। यह एक ऐसा कार्य है जिसे आप एक चर की तरह पास करते हैं। एक लैम्ब्डा अभिव्यक्ति एक अज्ञात प्रतिनिधि (या अज्ञात विधि, मेरे लिए अधिक सामान्य) के बराबर है।

यहाँ (बेशक, अपने इकाई के प्रकार के साथ EntityType की जगह TableA से लौटे) के रूप में प्रतिनिधियों लैम्ब्डा भाव से अपनी क्वेरी है:

if (db.TableA.Where(delegate(EntityType a) { return a.UserID == currentUser; }) 
    .Join(db.TableB.Where(delegate(EntityType b) { return b.MyField == someValue; }), 
     delegate(EntityType o) { return o.somefieldId); }, 
     delegate(EntityType i) { return i.someFieldId); }, 
     delegate(EntityType o, EntityType i) { return o; }) 
    .Any()) 

{ // ... }

नोट: एक लैम्ब्डा अभिव्यक्ति में महत्वपूर्ण पहलू हैं जो इसे अज्ञात तरीकों के बराबर के बराबर बनाते हैं। मैं अनुशंसा करता हूं कि आप अन्य SO प्रश्नों को देखें और विशेष रूप से लैम्ब्डा अभिव्यक्तियों के बारे में ऑनलाइन पढ़ें। वे बहुत शक्तिशाली विचारों को एक बहुत ही सरल और सुरुचिपूर्ण तरीके से व्यक्त करने की अनुमति देते हैं। यह एक गहरा विषय है, लेकिन मूल बातें समझने में काफी आसान हैं। यह एक ऐसा फ़ंक्शन है जिसे आप चर के समान या अन्य कार्यों के पैरामीटर के रूप में पारित कर सकते हैं।

Answer 2

इस क्वेरी कह रहा है TableATableB के लिए जहां TableA.someFieldID == TableB.someFieldID किसी भी और देखते हैं अगर TableA से परिणामों का चयन और देख में शामिल होने के हस्ताक्षर जरूरतों के मामले में कैसे परिणाम है सभी

एसक्यूएल के मामले में कम से परिणाम इस तरह यह के बारे में सोच, भले ही वह Linq करने वाली एसक्यूएल नहीं है ... यदि आप एसक्यूएल के साथ परिचित हैं शायद यह अधिक समझ में आता है:

Select Count(*) 
From TableA a 
    Join TableB b 
     On a.someFieldID = b.someFieldID 

तो जाँच यदि Count(*) है> 0

Answer 3

में शामिल होने के वाक्य रचना

FirstTable.Join(SecondTable, FirstTableKeyExtractor, SecondTableKeyExtractor, Selector) 

तो तुम दो तालिकाओं है। आपके पास कुछ कुंजी है जो दोनों टेबलों के लिए आम है। आप दो प्रमुख निकालने वाले प्रदान करते हैं जो जानते हैं कि तालिका में प्रत्येक पंक्ति से कुंजी कैसे प्राप्त करें।

जुड़ने वाले तर्क पंक्तियों के जोड़े की पहचान करते हैं, प्रत्येक तालिका में से एक, जिसमें एक ही कुंजी होती है।

तब उन पंक्तियों में से प्रत्येक को परिणाम प्रोजेक्ट करने के लिए चयनकर्ता के माध्यम से चलाया जाता है।

क्या यह आपके प्रश्न का उत्तर देता है?

Answer 4

जुड़ने का स्पष्टीकरण।

b पहले तालिका के = ऑब्जेक्ट प्रकार पहले तालिका के o = ऑब्जेक्ट प्रकार दूसरी तालिका के i = ऑब्जेक्ट प्रकार

1. db.TableB.Where(b => b.MyField == someValue) यह दूसरी तालिका
2. o => o.someFieldID के प्रमुख के तत्व प्रकार है पहली तालिका
3. i => i.someFieldID दूसरी तालिका की कुंजी (जो पहली तालिका में कुंजी से मेल खाती है)
4. (o,i) => o इस मामले में पहली तालिका के ऑब्जेक्ट प्रकार को वापस करने का ऑब्जेक्ट।