Discussion :

[youtpout978]

Bonjour,
je fais quelque essais pour rendre une méthode "générique" (je ne sais pas si c'est le bon terme ici).
J'ai donc une classe personne (Nom,Prenom,Pays,Age), une classe PersonneS qui est une List<Personne>, j'ai créer une méthode qui me retourne sous forme d'un Dictionary<string, int> le nombre de personne pour une propriété donnée ce qui m'évite de créer une méthode pour chaque propriété:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 public class Personnes : List<Personne>
    {
 
        public Personnes RecupererTous()
        {
            return new DB().RecupererPersonne();
        }
 
        public Dictionary<string, int> PersonnePar(string nomPropriete)
        {
            Dictionary<string, int> personnePar = new Dictionary<string, int>();
            try
            {
                if (this == null || this.Count == 0)
                {
                    this.AddRange(RecupererTous());
                }
 
                this.GroupBy(p => p.GetType().GetProperty(nomPropriete).GetValue(p, null)).Select(p => new
                {
                    Key = p.Key.ToString(),
                    Value = p.Count()
                })
                .ToList()
                .ForEach(t => personnePar.Add(t.Key, t.Value));
                // this.ForEach(p => NombreParPropriete(p, personneParPays, nomPropriete));
 
 
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return personnePar;
        }

j'aimerais déjà pouvoir directement retourner un Dictionary<string, int> avec ma requête linq et rendre ce Dictionnaire un peu plus générique par la suite (avoir un Dictionary<Tkey, int> dans le cas ou la propriété n'est pas forcément une string).

Si quelqu'un aurait une piste pour moi Merci.

(C'est un petit exercice personnel qui ne rentre pas dans le cadre d'un projet)

[tomlev]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
        public Dictionary<TProperty, int> PersonnePar<TProperty>(Func<Person, TProperty> selector)
        {
                if (this.Count == 0)
                {
                    this.AddRange(RecupererTous());
                }
 
                return this.GroupBy(selector).ToDictionary(g => g.Key, g => g.Count());
        }

Plusieurs remarques sur ton code d'origine :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

if (this == null || this.Count == 0)

C'est impossible, this ne peut jamais être null...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
            try
            {
                ...
            }
            catch (Exception ex)
            {
                throw ex;
            }

A quoi ça sert de faire un try/catch si c'est pour relancer aussitôt l'exception sans rien faire de plus ? Laisse l'exception remonter normalement...
En plus, en faisant throw ex, tu perds la pile d'origine de l'exception, il faut faire throw tout court.

p.GetType().GetProperty(nomPropriete).GetValue(p, null)

Utiliser la réflexion comme ça est terriblement lent... Il vaut mieux utiliser un delegate qui va se charger de récupérer la propriété. La méthode que j'ai écrite s'utilise comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

var personnesParAge = personnes.PersonnePar(p => p.Age);

En plus ça a l'avantage que tu ne peux pas te tromper en écrivant le nom de la propriété, car le compilateur vérifie

[youtpout978]

merci TomLev certaine chose était présente parce que la méthode était complètement différente à l'origine, faut que j'approfondisse mes connaissances au niveau des delegates et de leur utilisation (j'ai beau lire des tutos, leur utilisation m'échappe toujours pour autant)

[Nathanael Marchand]

Je suis parti manger du coup tomlev est passé entre temps.
J'ai donc une réponse qui ressemble:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
void Main()
{
	var list = new List<Personne>
	{
		new Personne{ Nom = "Lajoie", Prenom = "Toto", Age = 10 },
		new Personne{ Nom = "Lajoie", Prenom = "Bobby", Age = 20 },
	};
 
	CountByKey(list, p=>p.Nom).Dump();
	CountByKey(list, p=>p.Prenom).Dump();
	CountByKey(list, p=>p.Age).Dump();
 
	CountByKey<Personne,int>(list, "Age").Dump();
	CountByKey<Personne,String>(list, "Prenom").Dump();
}
 
Dictionary<TProp,int> CountByKey<TObj,TProp>(List<TObj> objects, Func<TObj,TProp> selector)
{
	return objects.GroupBy(o => selector(o)).ToDictionary (o => o.Key,o=>o.Count());
}
 
Dictionary<TProp,int> CountByKey<TObj,TProp>(List<TObj> objects, string property)
{
	var parameter = Expression.Parameter(typeof(TObj),"o");
	var func = Expression.Lambda<Func<TObj,TProp>>(Expression.Property(parameter, property),parameter).Compile();
	return CountByKey(objects, func);
}

Le CountByKey avec String est totalement gadget cela dit, c'était juste pour m'amuser je le trouve pas propre

[tomlev]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

.Dump()

encore un fan de LinqPad

[youtpout978]

pas mal ta solution Nathanael qui s'affranchit du type de List, justement je me demandais c'était quoi ce Dump?
Je pense que je peux passer à résolu.