Itération façon intelligente dans une liste avec LINQ

Question

j'ai cette classe simple:

public class JDEItemLotAvailability 
    { 
     public string Code { get; set; } 
     public int ShortCode { get; set; } 
     public string Description { get; set; } 
     public string PrimaryUnitCode { get; set; } 
     public string BranchPlant { get; set; } 
     public string Location { get; set; } 
     public string Lot { get; set; } 
     public int AvailableQuantity { get; set; } 
    } 

Cette méthode DAL dans mon BLL retourne une liste:

var returnedLotList = _JDE8dal.GetLotAvailabilityAsList(_lot); 

Je veux faire ce qui suit dans la liste retournée et je veux le faire de la manière la plus "élégante" LINQ.

Je veux vérifier s'il existe dans la liste un enregistrement qui correspond à des critères spécifiques. Je l'ai pensé à quelque chose comme ceci:

var query = 
     returnedLotList.Where(l => l.AvailableQuantity != 0 && l.BranchPlant == _mcu && l.Location == _locn) 
           .OrderByDescending(l => l.AvailableQuantity); 

mais je veux dire que si la requête ci-dessus ne retourne pas que je veux prendre le premier du reste des entrées de la liste.

Comment puis-je faire cela?

Answer 1

Vous pouvez simplement utiliser DefaultIfEmpty

//your first query, unaltered 
var query = 
     returnedLotList.Where(l => l.AvailableQuantity != 0 && l.BranchPlant == _mcu && l.Location == _locn) 
           .OrderByDescending(l => l.AvailableQuantity); 

var query2 = query.DefaultIfEmpty(returnedLotList.Take(1)); 

Answer 2

Vous pouvez faire une méthode d'extension qui fait cela:

public static IEnumerable<T> WhereOrFirstOfRest<T>(
    this IEnumerable<T> collection, Func<T, bool> predicate) 
{ 
    var filtered = collection.Where(predicate); 

    return filtered.Any() ? filtered : collection.Take(1); 
} 

Inconvénient de cette méthode d'extension est qu'elle parcourt la collection à plusieurs reprises. Cela peut être un problème lorsque vous traitez des flux (à partir de la base de données par exemple). Une méthode plus efficace serait la suivante:

public static IEnumerable<T> WhereOrFirstOfRest<T>(
    this IEnumerable<T> collection, Func<T, bool> predicate) 
{ 
    // Materialize the complete collection. 
    collection = collection.ToArray(); 

    // Filter the collection. ToArray prevents calling the predicate 
    // twice for any item. 
    var filtered = collection.Where(predicate).ToArray(); 

    return filtered.Any() ? filtered : collection.Take(1); 
} 

Bien que cela vous évite de tout possible des appels supplémentaires à la base de données, cela ne crée plusieurs nouveaux tableaux sous le couvercle. La façon la plus efficace whould donc les suivantes:

public static IEnumerable<T> WhereOrFirstOfRest<T>(
    this IEnumerable<T> collection, Func<T, bool> predicate) 
{ 
    T firstItem = default(T); 
    bool firstStored = false; 
    bool predicateReturnedItems = false; 

    foreach (var item in collection) 
    { 
     if (!firstStored) 
     { 
      firstItem = item; 
      firstStored = true; 
     } 

     if (predicate(item)) 
     { 
      yield return item; 
      predicateReturnedItems = true; 
     } 
    } 

    if (!predicateReturnedItems && !first) 
    { 
     yield return firstItem; 
    } 
} 

Answer 3

Je ne suis pas sûr que je comprends, mais peut-être quelque chose comme ceci:

var firstMatch = returnedLotList.FirstOrDefault(l => l.AvailableQuantity != 0 && 
                l.BranchPlant == _mcu && 
                l.Location == _locn); 
if (firstMatch != null) 
    return firstMatch; 
int max = returnedLotList.Max(l => l.AvailableQuantity); 
return returnedLotList.First(l => l.AvailableQuantity == max); 

• FirstOrDefault renverra null si aucune correspondance
• Je thi nk c'est une bonne idée de diviser les requêtes pour clarifier ce qui se passe.