Linq करने वाली संस्थाओं को शामिल करें()

Question

लोड नहीं अगर मैं एक में शामिल होने का उपयोग विधि, को शामिल करें() विधि अब काम नहीं कर, जैसे है में शामिल होने, शामिल करें() काम करता है

ली

Answer 1

अपडेट: असल में मैंने हाल ही में एक और युक्ति जो इसे कवर किया है, और एक वैकल्पिक संभव समाधान प्रदान करता है। Tip 22 - How to make include really include

---

वहाँ जाना जाता है सीमा इकाई की रूपरेखा में जब का उपयोग करके(): विचार शामिल के उपयोग में देरी करने के लिए है() क्वेरी के अंत तक, इस बारे में अधिक जानकारी के लिए देखें। कुछ संचालन केवल शामिल करने के साथ समर्थित नहीं हैं।

ऐसा लगता है कि, उन सीमाओं पर एक में चलाने हो सकता है इससे बचने के लिए आप कुछ इस तरह की कोशिश करनी चाहिए:

var results = 
    from e in dc.Entities //Notice no include 
    join i in dc.Items on e.ID equals i.Member.ID 
    where (i.Collection.ID == collectionID) 
    select new {Entity = e, Properties = e.Properties}; 

यह गुण वापस लाना होगा, और यदि इकाई और गुण के बीच संबंध है (कई लोगों के लिए एक बहुत नहीं बल्कि) कई लोगों के लिए एक एक आप देखेंगे कि प्रत्येक जिसके परिणामस्वरूप गुमनाम प्रकार में मान इसी मिलेगा:

anonType.Entity.Properties 
anonType.Properties 

इस इकाई की रूपरेखा बुलाया संबंध Fixup में एक सुविधा का एक पक्ष प्रभाव है।

अधिक जानकारी के लिए मेरे EF Tips series में यह Tip 1 देखें।

Answer 2

करना और अधिक या कम एक ही बात एक ही परिणाम प्राप्त है, लेकिन अधिक से के लिए और अधिक वर्बोज़ तरह से प्रयास करें डेटाकॉल:

var mydata = from e in dc.Entities 
      join i in dc.Items 
       on e.ID equals i.Member.ID 
      where (i.Collection.ID == collectionID) 
      select e; 

foreach (Entity ent in mydata) { 
    if(!ent.Properties.IsLoaded) { ent.Properties.Load(); } 
} 

क्या आपको अभी भी वही (अप्रत्याशित) परिणाम मिलता है?

EDIT: पहली वाक्य बदल दी गई, क्योंकि यह गलत थी। सूचक टिप्पणी के लिए धन्यवाद!

Answer 3

तो "आइटम" पर नेविगेशन प्रॉपर्टी का नाम क्या है जो "आइटम। मेम्बर" से संबंधित है (यानी, नेविगेशन का दूसरा छोर है)। आपको शामिल होने के बजाय इसका उपयोग करना चाहिए। उदाहरण के लिए, यदि "इकाई" 1 की प्रमुखता के साथ एक संपत्ति सदस्य कहा जाता है जोड़ सकते हैं और सदस्य एक संपत्ति कई का एक प्रमुखता के साथ आइटम कहा जाता था, तो आप ऐसा कर सकते हैं:

from e in dc.Entities.Include("Properties") 
where e.Member.Items.Any(i => i.Collection.ID == collectionID) 
select e 

मैं के गुणों पर अनुमान लगा रहा हूँ आपका मॉडल यहाँ है, लेकिन यह आपको सामान्य विचार देना चाहिए। ज्यादातर मामलों में, LINQ से इकाइयों में शामिल होने का उपयोग गलत है, क्योंकि यह सुझाव देता है कि या तो आपके नेविगेशन गुण सही तरीके से सेट नहीं किए गए हैं, या आप उनका उपयोग नहीं कर रहे हैं।

Answer 4

इस प्रयास करें:

var query = (ObjectQuery<Entities>)(from e in dc.Entities 
      join i in dc.Items on e.ID equals i.Member.ID 
      where (i.Collection.ID == collectionID) 
      select e) 

return query.Include("Properties") 

Answer 5

तो, मुझे लगता है मैं पार्टी यहाँ करने के लिए देर से कर रहा हूँ, लेकिन मैंने सोचा था कि मैं अपने निष्कर्षों को जोड़ने चाहते हैं।यह वास्तव में एलेक्स जेम्स की पोस्ट पर एक टिप्पणी होनी चाहिए, लेकिन जैसा कि मेरे पास प्रतिष्ठा नहीं है, उसे यहां जाना होगा।

तो मेरा जवाब है: ऐसा लगता है कि यह आपके जैसा इरादा नहीं है। एलेक्स जेम्स दो रोचक समाधान देता है, हालांकि यदि आप उन्हें आज़माते हैं और एसक्यूएल की जांच करते हैं, तो यह भयानक है।

उदाहरण मैं पर काम कर रहा था है:

 var theRelease = from release in context.Releases 
         where release.Name == "Hello World" 
         select release; 

     var allProductionVersions = from prodVer in context.ProductionVersions 
            where prodVer.Status == 1 
            select prodVer; 

     var combined = (from release in theRelease 
         join p in allProductionVersions on release.Id equals p.ReleaseID 
         select release).Include(release => release.ProductionVersions);    

     var allProductionsForChosenRelease = combined.ToList(); 

यह दो उदाहरण के सरल प्रकार है। बिना को शामिल यह पूरी तरह सम्मानजनक एसक्यूएल का उत्पादन:

SELECT 
    [Extent1].[Id] AS [Id], 
    [Extent1].[Name] AS [Name] 
    FROM [dbo].[Releases] AS [Extent1] 
    INNER JOIN [dbo].[ProductionVersions] AS [Extent2] ON [Extent1].[Id] = [Extent2].[ReleaseID] 
    WHERE ('Hello World' = [Extent1].[Name]) AND (1 = [Extent2].[Status]) 

लेकिन OMG, साथ:

SELECT 
[Project1].[Id1] AS [Id], 
[Project1].[Id] AS [Id1], 
[Project1].[Name] AS [Name], 
[Project1].[C1] AS [C1], 
[Project1].[Id2] AS [Id2], 
[Project1].[Status] AS [Status], 
[Project1].[ReleaseID] AS [ReleaseID] 
FROM (SELECT 
    [Extent1].[Id] AS [Id], 
    [Extent1].[Name] AS [Name], 
    [Extent2].[Id] AS [Id1], 
    [Extent3].[Id] AS [Id2], 
    [Extent3].[Status] AS [Status], 
    [Extent3].[ReleaseID] AS [ReleaseID], 
    CASE WHEN ([Extent3].[Id] IS NULL) THEN CAST(NULL AS int) ELSE 1 END AS [C1] 
    FROM [dbo].[Releases] AS [Extent1] 
    INNER JOIN [dbo].[ProductionVersions] AS [Extent2] ON [Extent1].[Id] = [Extent2].[ReleaseID] 
    LEFT OUTER JOIN [dbo].[ProductionVersions] AS [Extent3] ON [Extent1].[Id] = [Extent3].[ReleaseID] 
    WHERE ('Hello World' = [Extent1].[Name]) AND (1 = [Extent2].[Status]) 
) AS [Project1] 
ORDER BY [Project1].[Id1] ASC, [Project1].[Id] ASC, [Project1].[C1] ASC 

कुल कचरा। यहां ध्यान देने योग्य मुख्य बिंदु यह तथ्य है कि यह तालिका के बाहरी जुड़े संस्करण को वापस देता है जो स्थिति = 1 द्वारा सीमित नहीं है।

गलत डेटा में यह परिणाम नहीं दिए जा रहा है:

Id Id1 Name  C1 Id2 Status ReleaseID 
2 1 Hello World 1 1 2  1 
2 1 Hello World 1 2 1  1 

ध्यान दें कि 2 की स्थिति हमारे प्रतिबंध के बावजूद वहाँ वापस आ जा रहा है। यह बस काम नहीं करता है। अगर मैं कहीं गलत हो गया हूं, तो मुझे पता लगाना अच्छा लगेगा, क्योंकि यह लिंक का मजाक उड़ा रहा है। मुझे विचार पसंद है, लेकिन इस समय निष्पादन प्रयोग योग्य नहीं लगता है।

---

जिज्ञासा से बाहर, मैंने कोशिश की LinqToSql dbml बल्कि LinqToEntities edmx कि ऊपर गड़बड़ उत्पादन की तुलना में:

SELECT [t0].[Id], [t0].[Name], [t2].[Id] AS [Id2], [t2].[Status], [t2].[ReleaseID], (
    SELECT COUNT(*) 
    FROM [dbo].[ProductionVersions] AS [t3] 
    WHERE [t3].[ReleaseID] = [t0].[Id] 
    ) AS [value] 
FROM [dbo].[Releases] AS [t0] 
INNER JOIN [dbo].[ProductionVersions] AS [t1] ON [t0].[Id] = [t1].[ReleaseID] 
LEFT OUTER JOIN [dbo].[ProductionVersions] AS [t2] ON [t2].[ReleaseID] = [t0].[Id] 
WHERE ([t0].[Name] = @p0) AND ([t1].[Status] = @p1) 
ORDER BY [t0].[Id], [t1].[Id], [t2].[Id] 

थोड़ा अधिक कॉम्पैक्ट - अजीब गिनती खंड है, लेकिन कुल मिलाकर एक ही कुल असफल।

क्या किसी ने वास्तव में इस सामान को वास्तविक व्यापार एप्लिकेशन में उपयोग किया है? मैं वास्तव में आश्चर्यचकित करना शुरू कर रहा हूं ... कृपया मुझे बताएं कि मैंने कुछ स्पष्ट याद किया है, क्योंकि मैं वास्तव में लिंक पसंद करना चाहता हूं!