Salut,

J'étais habitué à tout monter "à la main" mais je me suis dit qu'EF pouvait faire une grosse partie du travail. alors j'ai tenté l'aventure EF.
Je suis en Framework 4.8 et je suis en lié à PostgreSQL via EF6, EF6.npgsql et npgsql.

D'abord à l'ouverture de l'application, avec EF la durée de connexion est tellement longue (plus de 6 sec) que j'avais moi-même tendance à vouloir cliquer plusieurs fois pour redémarrer l'appli. Donc l'utilisateur pensera aussi que ça a planté. J'ai donc dû ajouter un splashscreen.
Mais j'ai lu à quelques endroits qu'avec EF la première connexion est effectivement très lente.
Ensuite, une fois la première connexion passée, je trouve que le chargement d'une table est aussi très long.
Alors j'ai décidé de comparer.
Et les résultats sont édifiants. Il y a bel et bien une différence avec ou sans EF. Et pas une petite différence.
J'ai fais 3 tests :
1 : EF + requête linq : durée 08 sec 6717041
2 : EF + requête SQL : durée 09 sec 7228367
3 : connexion "standard" + requête SQL : Durée1 sec 1965210

On est quand-même dans un rapport 1/8. C'est énorme.

Le code du test
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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
            TimeSpan duree1;
            TimeSpan duree2;
            TimeSpan duree3;
            var sqlStr = @"SELECT DISTINCT greffe.personnes.* "
                        + "FROM greffe.personnes "
                        + "JOIN greffe.minutes_proprietaires ON greffe.minutes_proprietaires.id_personne = greffe.personnes.id_personne "
                        + "ORDER BY greffe.personnes.nom, greffe.personnes.prenom";
            try
            {
                DateTime deb1 = DateTime.Now;
                using (var ctr = new GreffeAdoModelContainer())
                {
                    var result = ctr.personnes.Include("minutes").Where(p => p.minutes.Any()).ToList();
                    Proprietaires = new ObservableCollection<personnes>(result);
                }
                duree1 = DateTime.Now - deb1;
 
 
                DateTime deb2 = DateTime.Now;
                using (var ctr = new GreffeAdoModelContainer())
                {
                    var test = ctr.personnes.SqlQuery(sqlStr).ToList();
                }
                duree2 = DateTime.Now - deb1;
 
 
                DateTime deb3 = DateTime.Now;
                ObservableCollection<personnes> testObs = new ObservableCollection<personnes>();
                using (var conn = new Npgsql.NpgsqlConnection(cs))
                {
                    conn.Open();
                    using (var cmd = new Npgsql.NpgsqlCommand(sqlStr, conn))
                    {
                        using (var dataReader = cmd.ExecuteReader())
                        {
                            while (dataReader.Read())
                            {
                                if (dataReader != null)
                                {
                                    personnes newPersonne = new personnes();
                                    newPersonne.id_personne = (int)dataReader["id_personne"];
                                    newPersonne.nom = dataReader["nom"].ToString();
                                    newPersonne.prenom = dataReader["prenom"].ToString();
                                    testObs.Add(newPersonne);
                                }
                            }
                        }
                    }
                }
                duree3 = DateTime.Now - deb3;
            }
            catch (Exception ex)
            {
 
 
            }
Et je rappelle les résultats : Duree1 = {00:00:08.6717041}, Duree2 = {00:00:09.7228367} et Duree3 = {00:00:01.1965210}
Je me dis que c'est pratiquement impossible qu'il y ait une telle différence et qu'en EF, même si je ne vois pas comment, je devrais peut-être requeter autrement parce qu'EF a l'air intéressant, mais avec des rendements pareils, je crois qu'il vaut mieux que je recode tout en "standard".
Qqn a-t-il une explication pour cette lenteur (et donc pour l'accélérer. Parce que +/-8 secondes à chaque ouverture de UserControl c'est plus que très long) ?