Comment puis-je compter efficacement les propriétés en double dans une liste d'objets à l'aide de LINQ ?

Comptage des doublons dans une liste d'objets avec LINQ

Étant donné une liste d'objets avec des propriétés uniques, déterminer le nombre de propriétés en double est une tâche difficile exigence courante en programmation. Grâce à la syntaxe LINQ (Language Integrated Query), cette tâche peut être accomplie efficacement.

Utilisation de GroupBy et OrderBy

L'approche fondamentale consiste à utiliser les opérateurs GroupBy et OrderBy de LINQ. GroupBy partitionne la liste en groupes en fonction d'une propriété spécifiée, tandis que OrderBy organise les groupes par ordre décroissant en fonction du nombre d'éléments.

var groupedItems = list.GroupBy(x => x.Property)
                    .Select(x => new { Property = x.Key, Count = x.Count() });

var orderedItems = orderedItems.OrderByDescending(x => x.Count);

Ce code regroupe les objets en fonction de la propriété spécifiée, calcule le nombre dans chacun groupe, puis trie les groupes par ordre décroissant par nombre.

Personnalisation de l'objet Comparaison

Dans les cas où les objets n'ont pas de propriété directement comparable, un comparateur personnalisé ou une expression lambda peut être défini. Par exemple, si les objets ont une propriété ID unique :

var groupedItems = list.GroupBy(x => new { x.Property, x.ID })
                    .Select(x => new { Property = x.Key.Property, Count = x.Count() });

Gestion de plusieurs propriétés

Pour prendre en compte plusieurs propriétés pour le regroupement, une clé composite peut être utilisée :

var groupedItems = list.GroupBy(x => new { x.Property1, x.Property2 })
                    .Select(x => new { Property1 = x.Key.Property1, Property2 = x.Key.Property2, Count = x.Count() });

Implémentation avec des méthodes d'extension

Pour un code plus performant Pour des raisons de concision, des méthodes d'extension peuvent être utilisées :

public static IEnumerable<t> CountDuplicates<t>(this IEnumerable<t> list, Func<t object> keySelector)
{
    return list.GroupBy(keySelector)
                .Select(x => new { Key = x.Key, Count = x.Count() });
}</t></t></t></t>

Cette méthode d'extension fournit un moyen réutilisable de compter les doublons en fonction de la fonction de sélection de clé spécifiée.

En exploitant la puissance de LINQ et en les exploitant Grâce à ces techniques, les développeurs peuvent gérer et analyser efficacement les données impliquant des valeurs en double dans des listes d'objets.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!