लिंक सभी खाली संग्रह पर

Question

मुझे यह जांचने की ज़रूरत है कि सभी परिभाषाओं में कुछ विशिष्ट डेटा है या नहीं। यह उस मामले को छोड़कर ठीक काम करता है जब ग्रुपबी खाली संग्रह देता है।

var exist = dbContext.Definitions 
        .Where(x => propertyTypeIds.Contains(x.PropertyTypeId) && x.CountryId == countryId) 
        .GroupBy(x => x.PropertyTypeId) 
        .All(...some condition...); 

इसे फिर से लिखने के लिए कैसे सभी खाली संग्रह पर झूठी वापसी करेंगे?

अद्यतन: यह एसक्यूएल के लिए एक LINQ है और मैं इसे एकल कॉल में निष्पादित करना चाहता था।

UPDATE2: मैं इस काम करता है लगता है:

var exist = dbContext.Definitions 
        .Where(x => propertyTypeIds.Contains(x.PropertyTypeId) && x.CountryId == countryId) 
        .GroupBy(x => x.PropertyTypeId) 
        .Count(x => x 
         .All(...some condition...)) == propertyTypeIds.Count; 

Answer 1

क्या अपना स्वयं का एक्सटेंशन विधि लिखने के बारे में?

public static bool NotEmptyAll<T>(
    this IEnumerable<T> collection, 
    Func<T, bool> predicate) 
{ 
    return collection != null 
     && collection.Any() 
     && collection.All(predicate); 
} 

तब की All

var exist = definitions.Where(
     x => propertyTypeIds.Contains(x.PropertyTypeId) && x.CountryId == countryId) 
     .GroupBy(x => x.PropertyTypeId) 
     .NotEmptyAll(
      ...some condition...)); 

Answer 2

खैर बजाय इसे कहते (मैं बहुत यकीन है कि आप इसे बेहतर नाम होगा), तो आपको दो चरणों में यह कर सकते हैं:

var definitions = definitions.Where(
        x => propertyTypeIds.Contains(x.PropertyTypeId) && x.CountryId == countryId) 
        .GroupBy(x => x.PropertyTypeId); 

var exist = definitions.Any() && definitions.All(...some condition...); 

Answer 3

आप कर सकते हैं Aggregate का उपयोग करके ऐसा करने में सक्षम हो जाएं:

.Aggregate(new {exists = 0, matches = 0}, (a, g) => 
     new {exists = a.exists + 1, matches = a.matches + g > 10 ? 1 : 0}) 

और फिर सरल तर्क exists शून्य और उस exists और matches से अधिक एक ही मूल्य है यह है कि (यहाँ, g > 10 अपने परीक्षण है)।

यह पूरी क्वेरी को दो बार चलाने से बचाता है।

Answer 4

आप DefaultIfEmpty विस्तार विधि का इस्तेमाल करते हैं, और अपने some condition इतना है कि यह मूल्यांकन करता nullfalse को समायोजित कर सकते हैं।

var exist = definitions 
    .Where(x => propertyTypeIds.Contains(x.PropertyTypeId) && x.CountryId == countryId) 
    .GroupBy(x => x.PropertyTypeId) 
    .DefaultIfEmpty() 
    .All(...some condition...)); 

Answer 5

संपादित करें: पहला उत्तर काम नहीं करेगा।

आप कुछ हद तक आपकी क्वेरी को पुनर्व्यवस्थित हैं, तो आप अपनी हालत बदले बिना DefaultIfEmpty उपयोग कर सकते हैं:

var exist = dbContext.Definitions 
        .Where(x => propertyTypeIds.Contains(x.PropertyTypeId) 
            && x.CountryId == countryId) 
        .GroupBy(x => x.PropertyTypeId); 

      // apply the condition to all entries, 
      // resulting in sequence of bools (or empty), 
      // to permit the next step 
        .Select(...some condition...) 

      //if seq is empty, add `false` 
        .DefaultIfEmpty(false) 

      //All with identity function to apply the query and calculate result 
        .All(b => b) 
     ); 

Answer 6

आप वस्तुओं को LINQ उपयोग कर रहे हैं, मैं बस अपना खुद का विस्तार विधि लिखना चाहते हैं।

public static bool AnyAndAll<TSource>(
    this IEnumerable<TSource> source, 
    Func<TSource, bool> predicate) 
{ 
    if (source == null) 
    { 
     throw new ArgumentNullException(nameof(source)); 
    } 
    if (predicate == null) 
    { 
     throw new ArgumentNullException(nameof(predicate)); 
    } 

    bool any = false; 
    foreach (TSource item in source) 
    { 
     any = true; 
     if (!predicate(item)) 
     { 
      return false; 
     } 
    } 
    return any; 
} 

इस इनपुट एक बार से अधिक का मूल्यांकन टाल: मेरी Edulinq projectAll के लिए नमूना कोड है, और अनुकूल है कि बहुत सरल है।

Answer 7

यहाँ एक और चाल है:

var exist = dbContext.Definitions 
    .Where(x => propertyTypeIds.Contains(x.PropertyTypeId) && x.CountryId == countryId) 
    .GroupBy(x => x.PropertyTypeId) 
    .Min(some_condition ? (int?)1 : 0) == 1; 

यह इस तथ्य का इस्तेमाल करता है कि ऊपर Min<int?> विधि रिटर्न:

(ए) null जब सेट खाली है
(बी) 0 अगर कुछ तत्व
(सी) 1 के लिए स्थिति संतुष्ट नहीं है अगर स्थिति सभी तत्वों के लिए संतुष्ट है

इसलिए हम निरर्थक मूल्य तुलना नियमों का उपयोग करके (सी) के परिणाम को सरल जांचते हैं।