Discussion :

[olivier252]

Bonjour,
J'ai un problème de compréhension conceptuel au niveau du fonctionnement du modèle avec des DAO.

Nous avons réalisé en cours il y a peu de temps une application WPF sous forme d'un client lourd qui permet d'importer des données de notre BDD en format CSV. Pour cela nous avons utilisé
Entity Framework. Le prof nous a expliqué que l'avantage d'utiliser l'ORM EF permet d'éviter au développeur d'impacter directement sa BDD lors de la gestion des données en ajoutant une couche d'abstraction
grâce aux DAO.

C'est précisement cela que je ne comprends pas. L'application contient un service qui gère le crud avec des requêtes linq qui interagissent avec les objets et les modifie (delete, insert, ou update). Dès lors que j'appelle mon service
et l'une de ses méthodes je modifie directement la BDD. Je ne saisis pas où est le concept d'abstraction.

Voici un schéma :



Ainsi que le code de mon service

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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ModeleCshapG4.Services
{
    public static class ServicesDonnees
    {
        public static void AddNewCapteur(int numcapteur, string lieu)
        {
            using (var context = new GestionCapteurEntities())
            {
                var capteur = new Capteurs
                {
                    num_capteur = numcapteur,
                    lieu = lieu
                };
 
                context.Capteurs.Add(capteur);
                context.SaveChanges();
            }
        }
        public static List<Capteurs> readAllCapteur()
        {
            using (var context = new GestionCapteurEntities())
            {
                return context.Capteurs.ToList();
            }
        }
        public static void AddReleve(DateTime dateReleve, int idcapteur, decimal temperatur, decimal hygrometry)
        {
            using (var context = new GestionCapteurEntities())
            {
                var releve = new Releves
                {
 
                    releve_DTTM = dateReleve,
                    temperature = temperatur,
                    hygrometrie = hygrometry,
                    id_capteur = idcapteur,
                    insertion_DTTM = DateTime.Now
                };
 
                context.Releves.Add(releve);
                context.SaveChanges();
            }
 
        }
        public static void SaveCapteur(Capteurs capteur)
        {
            using (var context = new GestionCapteurEntities())
            {
                var entity = context.Capteurs.Find(capteur.id_capteur);
                entity.Releves = capteur.Releves;
                context.SaveChanges();
            }
        }
 
 
        public static Capteurs getCapteurInfo(int numCapteur)
        {
            using (var context = new GestionCapteurEntities())
            {
                return context.Capteurs.Include("Releves").Where(c => c.num_capteur == numCapteur).FirstOrDefault();
            }
        }
 
 
        public static IEnumerable<int> getFilteredListCapteur(string filter)
        {
            return (from c in readAllCapteur() where c.num_capteur.ToString().Substring(0, Math.Min(filter.Length, c.num_capteur.ToString().Length)) == filter select c.num_capteur);
        }
 
 
        public static void DeleteReleves(IList<Object> listReleves)
        {
            using (var context = new GestionCapteurEntities())
            {
                foreach (Releves Rel in listReleves)
                {
                    Releves releves = context.Releves.Find(Rel.id_releve);
                    context.Releves.Remove(releves);
                }
                context.SaveChanges();
            }
        }
    }
}

Je précise que pour l'exercice nous sommes partis sur une approche orientée données ce qui nous a permis de générer le dossier EDMX à partir de la BDD

Merci pour votre aide

[Pol63]

peut etre qu'il veut dire que si tu changes de base de données (genre d'sql server à oracle) ca ne change pas ton code ...
après dans les faits rares sont ceux qui changent de support
et EF a aussi des défauts

[olivier252]

Ok, merci de ta réponse

DU coup je me demande qui contient les requêtes : c'est au service ou au DAO ? Car je regarde un tuto et là les link sont dans le DAO, alors que moi c'est dans le service.
Pareil, je suis perdu au niveau des entités : quand on parle d'entités, il s'agit des objets métier ou des tables relationnelles qui sont mappées avec les objets ?

Désolé pour ces questions si basiques, mais je m'y perds

[Pol63]

e comprends pas trop ce que tu dis ... en partie parce que c'est très théorique je pense ^^
un ORM créé des classes en fonction du schéma de la base de données, ce sont les entités (genre une classe personne, une classe adresse, personne ayant entre autre une propriété de type adresse)
il génère les requetes selon ce que tu écris en linq pour que ca fonctionne sur la base de données utilisée (par toujours au mieux ^^)
après je vois pas ce que tu appelles service dans ton histoire
après souvent on utilise le "mot" DAL, ca doit être ce que tu appelles DAO
DAL (data access layer) étant la couche d'accès aux données dans un programme avec des couches séparées, où l'on y met des méthodes simples qui ne font que lire/écrire des données et sont appelées par une couche métier

[olivier252]

Effectivement je ne suis pas très clair je pense. Mis ton post m'a éclairé.
le DAL contient les méthodes qui contiennent le linq du type getTrucById(int id), DeleteTrucById().... qui va chercher l'info dans la couche de données (le contexte ?)
Ensuite ces méthodes sont appelées par la couche métier (ce que j'appelle peut-être à tort service) pour la renvoyer à la vue.
Merci de ton aide

[Mat.M]

Le prof nous a expliqué que l'avantage d'utiliser l'ORM EF permet d'éviter au développeur d'impacter directement sa BDD lors de la gestion des données en ajoutant une couche d'abstraction
grâce aux DAO.
Je ne saisis pas où est le concept d'abstraction.

L'intérêt de créer une couche d'abstraction quel est-il ?
L'intérêt c'est que si sur le projet on passe par exemple d'Oracle à MS-Sqlserver comme SGBDR et que l'on change du module permettant d'accèder aux données eh bien pas besoin de refaire du code ;
c'est ça l'avantage majeur de l'Entity Framework et des architectures n-tiers
C'est un truc que le prof aurait dû vous expliquer

[foetus]

il me semble qu'il y a 3 avantages

• pourvoir changer de SGBD/ NoSQL sans modifier le code.
• pourvoir changer le schéma sans modifier le code. Après si tu changes les données (type, taille, cardinalité, ...), il faudra sûrement changer plus que la couche d'abstraction.
• pourvoir avoir des bases de données en local et en réseau, c'est transparent.

De ma petite expérience, même dans les petites applications avec base de données, tu as toujours 1 mini DAL afin de centraliser les requêtes SQL.