लैम्ब्डा भाव से आदेश और इस मुद्दे को

Question

ले रहा COLOURS वर्ग प्रकार के साथ एक IQueryable सूची

IQueryable<COLOURS> renkler = dbcontext.colours.Select(s=>new COLOURS{ .... 

मैं यादृच्छिक 2 पंक्तियाँ प्राप्त करना चाहते हैं, मैं इस कोड ब्लॉक का उपयोग कर रहा यह करने के लिए है:

renkler.OrderBy(o => Guid.NewGuid()).Take(2); 

:

मैं 2 पंक्तियाँ लेकिन कभी कभी अपनी हो रही 3 पंक्तियों या 5 पंक्तियाँ चाहते

Take(2) काम नहीं कर रहा है - समस्या क्या है?

मैं कुछ देखा है जब मैं

var result = NewProducts().OrderBy(o => Guid.NewGuid()).Take(2); 
int result_count = result.Count(); //This value is 2 :D 
            //but ToList() result 5 :D 

पूरे विधि की जाँच करें:

public IQueryable<COLOURS> NewProducts() 
{ 
    DateTime simdi = DateTime.Now; 
    DateTime simdi_30 = DateTime.Now.AddDays(-30); 

    var collection_products = DefaultColours() 
          .Where(w => ((w.add_date.Value >= simdi_30 && w.add_date.Value <= simdi) || w.is_new == true)) 
          .OrderByDescending(o => o.add_date).Take(200) 
          .Select(s => new COLOURS 
          { 
           colour_code = s.colour_code, 
           model_code = s.products.model_code, 
           sell_price = (decimal)s.sell_price, 
           market_price = (decimal)s.market_price, 
           is_new = (bool)s.is_new, 
           product_id = (int)s.product_id, 
           colour_name = s.name, 
           product_name = s.products.name, 
           description = s.products.description, 
           img_path = s.product_images.FirstOrDefault(f => f.is_main == true).img_path, 
           category_id = (int)s.category_relations.FirstOrDefault().category_id, 
           display_order = (short)s.display_order, 
           section_id = (int)s.products.section_id, 
           stock_amount = s.pr_sizes.Where(w => w.is_active == true && w.quantity >= 0).Count() > 0 ? (int)s.pr_sizes.Where(w => w.is_active == true && w.quantity >= 0).Sum(s2 => s2.quantity) : 0, 
                     section_name = s.products.pr_sections.name, 

          });  
    return collection_products; 
} 

public IQueryable<COLOURS> RandomNewProducts(int n) 
{ 
    var result = NewProducts().OrderBy(o => Guid.NewGuid()).Take(n); 
    int result_count = result.Count(); //2 
    //When I run this method it's getting 5 rows    
    return result; 
} 

Answer 1

यह आपको करने के लिए कोई समाधान हो सकता है, लेकिन यह बहु कोड और छवियों के साथ टिप्पणी फ़ॉर्मेट करने के लिए मुश्किल है।

मुझे पूरा यकीन है कि यह आपके डेटा प्रदाता के साथ एक मुद्दा है। शायद यह घटक Take() को जिस तरह से करना चाहिए उसे लागू नहीं करता है।

मैं अपने नक्षत्र पुनर्निर्माण करने की कोशिश, लेकिन किसी भी IQueryable प्रदाता के बजाय मैं 500 वस्तुओं के साथ एक List<> बनाया और उस पर AsQueryable() बुलाया विधि हस्ताक्षर को पूरा करने के।

public static IQueryable<COLOURS> DefaultColours() 
    { 
     const int COUNT = 500; 

     List<COLOURS> x = new List<COLOURS>(); 

     var startDate = DateTime.Today.AddDays(-1 * (int)(COUNT/2)); 

     // add 500 date values, and use the date and any random bool value 
     for (int i = 0; i < COUNT; i++) 
      x.Add(new COLOURS() { add_date = startDate.AddDays(i), is_new = i % 3 == 0 }); 

     return x.AsQueryable(); 
    } 

लेकिन जब मैं यह करते हैं, Take() विधि हमेशा दो (भिन्न) आइटम जब भी वापस लौटने है - बस के रूप में किसी को भी उम्मीद करेंगे:

Answer 2

यह ओ के कारण हो सकता = > Guid.NewGuid() lambda।

सॉर्टिंग एल्गोरिदम के लिए प्रत्येक तत्व से जुड़ी एक अनूठी कुंजी की आवश्यकता होती है। कॉलिंग Guid.NewGuid() का अर्थ है कि किसी भी दिए गए तत्व को इसके साथ जुड़े कई कुंजी हो सकती हैं जब इसे कॉल किया जाता है। लिंक सेट पर काम करने के तरीके में अवसरवादी होने का प्रयास करता है, इसलिए यह उदाहरण दे सकता है सॉर्टिंग ऑपरेशन के दौरान अचानक निम्नतम दो तत्व अब सबसे कम दो तत्व नहीं हैं।

यादृच्छिक पूर्णांक की एक सूची को सॉर्ट करने का प्रयास करने पर विचार करें, जहां सॉर्टिंग एल्गोरिदम उन्हें पुनर्प्राप्त करने का प्रयास करते समय हर इंटीजर यादृच्छिक रूप से बदल रहे हैं। यह काम करने का एकमात्र तरीका यह है कि अगर सॉर्टिंग एल्गोरिदम प्रत्येक तत्व के लिए एक बार और केवल एक बार कुंजी फ़ंक्शन को कॉल करने की गारंटी प्रदान करता है।

ऑर्डरबी पर प्रलेखन यह नहीं कहता कि सॉर्टिंग एल्गोरिदम को प्रत्येक तत्व के लिए एक से अधिक बार कुंजी फ़ंक्शन को कॉल करने की अनुमति है या नहीं, इसलिए सबसे खराब मामला मानना ​​सबसे अच्छा है जब तक कि आप अन्यथा साबित न कर सकें।

इसका परीक्षण करने के लिए एक (उम्मीदवार) सरल तरीका के रूप में, यदि आप अस्थायी रूप से यादृच्छिक कुंजी को अपने रंग ऑब्जेक्ट के लगातार तत्व के रूप में शामिल कर सकते हैं तो क्रम के दौरान ऑर्डर नहीं बदलेगा। टेक() को बिल्कुल ठीक काम करना चाहिए जैसा सोचा वैसा।

इसके अलावा, Guid।न्यूगुइड() तेज़ नहीं है, इसलिए उस अस्थायी परीक्षण को स्थायी समाधान में बदलना जो प्रत्येक ऑब्जेक्ट के लिए थोड़ी अधिक मेमोरी का उपयोग करता है, आपके कोड की गति में भी सुधार कर सकता है।