संबंधित वस्तुओं के साथ Entify फ्रेमवर्क क्वेरी को भरने के लिए कारगर तरीका?

वोट
0

मैं वस्तुओं का एक सेट के लिए एफई उपयोग कर रहा हूँ और दो अन्य तालिकाओं से मिलान प्रविष्टियों के साथ वस्तु का एक प्रकार क्वेरी करना चाहते हैं। यह एक एक्सएमएल उत्पादन में क्वेरी डंप करने के लिए है। सबसे पहले, एक में शामिल होने के बाद से मूल डेटा में प्रयोग की गयी प्रत्येक कर्मचारी हमेशा एक की 1+ उदाहरणों था कंप्यूटर ऑब्जेक्ट (समाधान # 2 नीचे), लेकिन यह जरूरी नहीं कि सच नहीं है।

उद्देश्य यहां के लिए, कल्पना:

  • एक कर्मचारी वस्तु,
  • प्रत्येक कर्मचारी एक है EmployeeType (कुछ तय प्रविष्टियों) और
  • प्रत्येक कर्मचारी है शून्य या एक से अधिक कम्प्यूटर वस्तुओं (आमतौर पर 0-3)।
  • प्रत्येक कम्प्यूटर अंतर्गत आता है एक कर्मचारी के लिए, नहीं सभी कर्मचारी एक कंप्यूटर है।
  • प्रत्येक कर्मचारी एक मापदंड (जैसे, जिस पर खोज आधारित है प्रभाग )।

इसलिए मैं कई संभव समाधान देखा:

  1. का प्रयोग करें Employee.Computer.Load () एक पाश के भीतर है, लेकिन 10,000+ पंक्तियों के साथ, कि एक विशाल प्रदर्शन दंड का कारण बनता है।

  2. एक का प्रयोग करें में शामिल होने क्वेरी में है, लेकिन यह सब बाहर छोड़ देता है कर्मचारी एक की जरूरत नहीं है कि कंप्यूटर

  3. संस्थाओं के लिए LINQ का उपयोग, लेकिन यह है कि # 1 की भूमि के ऊपर है लगता है: जब लोड हो रहा है कंप्यूटर है यह प्रत्येक के लिए डेटाबेस हिट कर्मचारी

  4. एक दूसरे क्वेरी (सभी का उपयोग कंप्यूटर से मेल खाते के साथ Computer.Employee.Division ), तो में कर्मचारी पाश, किसी को भी जोड़ कंप्यूटर दिए गए कर्मचारी के लिए। हालांकि यह लागू करने, मैंने पाया कि सिर्फ दूसरे क्वेरी चलाने (साथ ToList () ) एफई सही भरता Employee.Computer वस्तुओं की आवश्यकता के साथ सूची।

इधर, # 4 भार केवल 2 डाटाबेस के साथ डेटा 10k + के बजाय मारता है, और EntityFramework वास्तव में वस्तुओं, समेकन एवं संबंधों के सभी बनाता है।

मेरे प्रश्न :

  • # 4 के साथ, तथ्य यह है कि एफई भरता है Employee.Computer सूची कुछ है जिस पर मुझे लगता है मैं भरोसा कर सकते हैं? यदि हां, तो क्या आप मुझे प्रलेखन को इंगित कर सकते हैं?
  • वहाँ # 4 की तुलना में एक बेहतर तरीका है?

अद्यतन : ठीक है, मैथुन। क्षमा करें, लेकिन मैं बस इसे उड़ा दिया। मैं कम्प्यूटर तालिका के साथ संबंध पर ध्यान केंद्रित कर और तथ्य यह है कि मैं एक स्पष्ट था याद किया गया था Employee.EmployeeTypeReference.Load () डब्ल्यू / अशक्त के लिए पहला परीक्षण है, तो कंप्यूटर सूची ओ एक पूरा गैर मुद्दा था।

मैं केवल यह जब कुछ प्रदर्शन परीक्षण चल रहा है और मिश्रण करने के लिए क्रेग की समाधान जोड़ने पाया। सच में, रिकॉर्ड कर्मचारी और कंप्यूटर लेकिन संक्षेपण हैं, कर रहे हैं और मैं (सशर्त) XML आउटपुट में हर क्षेत्र में शामिल हैं, लेकिन वे छोटे कर रहे हैं: एक नाम, आईडी (पी) और आईडी (FK) प्लस कर्मचारी मेज पर एक INT। तो, मेरा अनुमान था कि प्रदर्शन के समान होने के बाद से एफई वस्तुओं प्रक्षेपण से नहीं अधिक भारी बनाने जाएगा।

वैसे भी, यहाँ परिणाम wher बीता समय इस क्वेरी से पहले अंतर था और बाद परिणामी एक्सएमएल बनाया गया था रहे हैं।

  • केस 1: एक ही # 2 के रूप है, लेकिन साथ शामिल करें () बयान:

    list = ve.Employee.Include(Computer).Include(EmployeeType).Where(e => e.Division.ID == divId).OrderBy(e => e.Name);

    बीता: 4,96, 5.05

  • केस 2: में लाइन का उपयोग करता है लोड () :

    list = ve.Employee.Where(e => e.Division.ID == divId).OrderBy(e => e.Name);

    बीता: 74.62

  • केस 3: वही # के रूप में 4, लेकिन साथ शामिल करें () बयान:

    list = from e in ve.Employee.Include(Computer).Include(EmployeeType) where e.Division.ID == divId orderby e.Name select e;

    बीता: 4.91, 5.47

  • प्रकरण 4: में लाइन का उपयोग करता है लोड () :

    list = from e in ve.Employee where e.Division.ID == divId orderby e.Name select e;

    बीता: 74.20

  • प्रकरण 5: * उपयोग शामिल है ( EmployeeType) और अलग कंप्यूटर क्वेरी, चलो एफई सहयोगी:

    elist = ve.Employee.Include(EmployeeType).Where(te => te.Division.ID == divId).OrderBy(e => e.Name).ToList(); alist = ve.Alias.Where(a => a.Employee.Division.ID == divId).ToList();

    बीता: 4.50, 4.02

  • प्रकरण 6: अनुमानों के क्रेग के सुझाव:

    elist = from te in ve.ThesaurusEntry where te.Division.ID==divID orderby te.Name select new { ID = te.ID, Name = te.Name, Type = te.EmployeeType.Name, Freq = te.Frequency, Aliases = from a in te.Alias select new { ID = a.ID, Name = a.Name } };

    बीता: 0.73, 1.25

निष्कर्ष

लोड () महंगा है, इसलिए उपयोग शामिल करें () या कम से कम के साथ परीक्षण IsLoaded

प्रोजेक्शन थोड़ा कठिन है, लेकिन एफई ठीक-अप की तुलना में काफी तेज है। [पर संकीर्ण टेबल इस सीमित परीक्षण के साथ]

26/08/2009 को 23:16
का स्रोत उपयोगकर्ता
अन्य भाषाओं में...                            


2 जवाब

वोट
2

मुझे विश्वास है कि आपको लगता है कि संबंधों किया जा सकता है पहले से लोड संकेत कर सकते हैं

Dim employees = From emp in db.Employees.Include("Computer") _
                Select emp
27/08/2009 को 01:06
का स्रोत उपयोगकर्ता

वोट
1

रोब के समाधान के लिए काम करेंगे (+1), लेकिन अगर आप में, कहते हैं, कर्मचारी और कंप्यूटर क्षेत्रों के सभी की जरूरत नहीं है, मैं चाहता हूँ दृढ़ता बजाय पेश की सलाह देते हैं:

var q = from e in Context.Employees
        where e.Division.Id = divisionId
        select new
        {
            Name = e.Name,
            EmployeeType = e.EmployeeType.Description,
            ComputerIds = from c in e.Computers
                          select new 
                          {
                              Id = c.Id
                          }
        };

यहाँ आप सभी आप एक क्वेरी में की जरूरत है, लेकिन पाने के ज्यादा कुछ नहीं : सभी फ़ील्ड आप वापस नहीं लौटाई जाएगी जरूरत नहीं है।

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

# 4 के बारे में, हाँ, तो आप इस पर भरोसा कर सकते, लेकिन यह हमेशा की जांच करने के लिए अच्छा है IsLoadedकॉल करने से पहले Load()

27/08/2009 को 14:17
का स्रोत उपयोगकर्ता

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more