.NET Framework - Explication détaillée du code technique « regroupement » dans les collections et LINQ

Nous regroupons souvent selon un ou plusieurs attributs individuels dans une collection de mémoire, telle que Liste, et affichons des statistiques. La façon la plus simple de penser est de parcourir l'instance List en fonction d'un certain attribut clé et de la convertir dans le type de dictionnaire suivant

Dictionary<string, List<MyObject>

Par exemple, des voitures données,

                List<Car> cars = new List<Car>(){                
                new Car(1,"audiA6","private"),                
                new Car(2,"futon","merchant"),                
                new Car(3,"feiren","bike"),                
                new Car(4,"bukon","private"),                
                new Car(5,"baoma","private"),                
                new Car(6,"dayun","merchant")
            };

Je voudrais utiliser id est la clé et la valeur est Car, qui est convertie en dictionnaire idCarDict En plus de parcourir cette méthode, qui a la logique la plus compliquée et nécessite le plus de code, nous pouvons également utiliser directement la méthode ToDictionary,

ar idCarDict = cars.ToDictionary(car=>car.id);

Cependant, cette méthode est limitée, il ne peut y avoir qu'une seule instance de l' objet correspondant au code clé, c'est-à-dire que le type renvoyé est

Dictionary<string,Object>

. C'est mauvais, car un code clé peut correspondre à plusieurs instances, à ce stade, vous devez d'abord utiliser GroupBy pour regrouper par code clé, puis le convertir en dictionnaire.

Par exemple, nous voulons utiliser le type comme clé pour obtenir plusieurs voitures sous ce modèle

Dictionary<string, List<Car>> typeCarDict = 
cars.GroupBy(car => car.type).
ToDictionary(g => g.Key, g => g.ToList());

Ce code de conversion est simple et bien meilleur que la logique de traversée suivante !

var dict = new Dictionary<string,List<Car>>();foreach(var car in cars)
{  if(dict.Contains(car.type))
     dict[car.type].Add(car);
  else
    dict.Add(car.type,new List<Car>(){car}));}

Cela résout le problème d'un code clé correspondant à plusieurs instances. Ensuite, selon le problème de plusieurs codes clés correspondant à plusieurs instances, cela peut-il être réalisé à l'aide de GroupBy sur la liste ? Impossible à réaliser.

À ce stade, vous devez écrire une instruction Linq pour combiner plusieurs codes clés dans un nouvel objet

new {key1, key2, ...}

À titre d'exemple, nous avons un tel ensemble d'éléments dans le. set est un objet ValPair, cet objet contient deux éléments entiers, Val1 est le plus petit et Val2 est relativement plus grand. Comment regrouper selon la combinaison de Val1 et Val2 ?
Veuillez consulter la logique suivante :

        static void printfDuplicateCompare(List<ValPair> compares)
        {            //按组合键分组后，每组元素个数大于2的分组，按降序排序
            var rtnByVal1 = from item in compares                            
            group item by new { item.Val1, item.Val2 }                                
            into g                                
            where g.Count()>1
                                orderby g.Count() descending
                                select g;            //按Val1和Val2组合为字典键，元素个数为值
            var dict = rtnByVal1.ToDictionary(g => g.Key,g=>g.Count());
        }

Résumé

Le GroupBy de la liste ne peut être regroupé que par une seule touche. Si vous devez regrouper par plusieurs combinaisons de touches, vous devez écrire un. Combinaison d'instructions Linq.

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!