Comment exécuter .Max() sur une propriété de tous les objets d'une collection et retourner l'objet ayant la valeur maximale ?

Question

J'ai une liste d'objets qui ont deux propriétés int. La liste est le résultat d'une autre requête linq. L'objet :

public class DimensionPair  
{
    public int Height { get; set; }
    public int Width { get; set; }
}

Je veux trouver et renvoyer l'objet de la liste qui a la plus grande taille. Height valeur de la propriété.

Je parviens à obtenir la valeur la plus élevée de l'élément Height mais pas l'objet lui-même.

Puis-je faire cela avec Linq ? Comment ?

Answer 1

Nous avons un méthode d'extension pour faire exactement cela dans PlusLINQ . Vous pouvez consulter l'implémentation à cet endroit, mais il s'agit essentiellement d'itérer à travers les données, en se souvenant de l'élément maximal que nous avons vu jusqu'à présent et de la valeur maximale qu'il a produite dans le cadre de la projection.

Dans votre cas, vous feriez quelque chose comme :

var item = items.MaxBy(x => x.Height);

C'est mieux (IMO) que toutes les solutions présentées ici, à l'exception de la deuxième solution de Mehrdad (qui est fondamentalement la même que MaxBy ) :

• C'est O(n) contrairement à la réponse précédente acceptée qui trouve la valeur maximale à chaque itération (ce qui fait O(n^2))
• La solution de commande est O(n log n)
• Prendre le Max et ensuite trouver le premier élément avec cette valeur est O(n), mais itère deux fois sur la séquence. Dans la mesure du possible, vous devriez utiliser LINQ en un seul passage.
• Elle est beaucoup plus simple à lire et à comprendre que la version agrégée, et n'évalue la projection qu'une fois par élément.

Answer 2

Cela nécessiterait une sorte (O(n journal n)) mais est très simple et flexible. Un autre avantage est de pouvoir l'utiliser avec LINQ to SQL :

var maxObject = list.OrderByDescending(item => item.Height).First();

Notez que cette méthode présente l'avantage d'énumérer les éléments suivants list séquence juste une fois. Même si cela n'a pas d'importance si list es un List<T> que cela ne change pas entre-temps, cela pourrait avoir de l'importance pour l'arbitraire. IEnumerable<T> objets. Rien ne garantit que la séquence ne change pas dans les différentes énumérations, donc les méthodes qui le font plusieurs fois peuvent être dangereuses (et inefficaces, selon la nature de la séquence). Cependant, c'est toujours une solution moins qu'idéale pour les grandes séquences. Je suggère d'écrire votre propre MaxObject extension manuelle si vous avez un grand ensemble d'éléments pour pouvoir le faire en une seule passe sans tri et autres trucs du genre (O(n)) :

static class EnumerableExtensions {
    public static T MaxObject<T,U>(this IEnumerable<T> source, Func<T,U> selector)
      where U : IComparable<U> {
       if (source == null) throw new ArgumentNullException("source");
       bool first = true;
       T maxObj = default(T);
       U maxKey = default(U);
       foreach (var item in source) {
           if (first) {
                maxObj = item;
                maxKey = selector(maxObj);
                first = false;
           } else {
                U currentKey = selector(item);
                if (currentKey.CompareTo(maxKey) > 0) {
                    maxKey = currentKey;
                    maxObj = item;
                }
           }
       }
       if (first) throw new InvalidOperationException("Sequence is empty.");
       return maxObj;
    }
}

et l'utiliser avec :

var maxObject = list.MaxObject(item => item.Height);

Answer 3

Effectuer un classement puis sélectionner le premier élément, c'est perdre beaucoup de temps à classer les éléments après le premier. Vous ne vous souciez pas de l'ordre de ceux-ci.

Au lieu de cela, vous pouvez utiliser la fonction d'agrégation pour sélectionner le meilleur élément en fonction de ce que vous recherchez.

var maxHeight = dimensions
    .Aggregate((agg, next) => 
        next.Height > agg.Height ? next : agg);

var maxHeightAndWidth = dimensions
    .Aggregate((agg, next) => 
        next.Height >= agg.Height && next.Width >= agg.Width ? next: agg);

Answer 4

Et pourquoi tu n'essaies pas avec ça ? :

var itemsMax = items.Where(x => x.Height == items.Max(y => y.Height));

OU plus optimiser :

var itemMaxHeight = items.Max(y => y.Height);
var itemsMax = items.Where(x => x.Height == itemMaxHeight);

mmm ?

Answer 5

Je pense que le fait de trier par la colonne dont vous voulez obtenir le MAX et de saisir le premier devrait fonctionner. Cependant, s'il y a plusieurs objets avec la même valeur MAX, un seul sera saisi :

private void Test()
{
    test v1 = new test();
    v1.Id = 12;

    test v2 = new test();
    v2.Id = 12;

    test v3 = new test();
    v3.Id = 12;

    List<test> arr = new List<test>();
    arr.Add(v1);
    arr.Add(v2);
    arr.Add(v3);

    test max = arr.OrderByDescending(t => t.Id).First();
}

class test
{
    public int Id { get; set; }
}