Discussion :

[Kropernic]

Je reviens à la charge avec ces histoire de DTO et de POCO .

Histoire de parler un exemple concret, voici un "bête" exemple de DTO (et des parsers qui vont avec en référence à la série d'articles de R. Lacovara)
Les DTO's :

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
Public Class BaseDTO
    Public Property IsNew As Boolean
End Class
 
Public Class AnimalDTO
    Inherits BaseDTO
    Public Sub New(age As Integer, nom As String)
        Me.Age = age
        Me.Nom = nom
    End Sub
 
    Public Property Age As Integer
    Public Property Nom As String
End Class
 
Public Class SerpentDTO
    Inherits AnimalDTO
 
    Public Sub New(age As Integer, nom As String, nombreMue As Integer)
        MyBase.New(age, nom)
        Me.NombreMue = nombreMue
    End Sub
 
    Public Property NombreMue As Integer
End Class
 
Public Class ChienDTO
    Inherits AnimalDTO
 
    Public Sub New(age As Integer, nom As String, nombrePortee As Integer)
        MyBase.New(age, nom)
        Me.NombrePortee = nombrePortee
    End Sub
 
    Public Property NombrePortee As Integer
End Class

Les parsers :

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
Public Interface IParser
    Sub PopulateOrdinals(reader As SqlClient.SqlDataReader)
    Function PopulateDTO(reader As SqlClient.SqlDataReader) As BaseDTO
End Interface
 
Public Class AnimalParser
    Implements IParser
 
    Private ord_age, ord_nom, ord_portee As Integer
 
    Public Function PopulateDTO(reader As System.Data.SqlClient.SqlDataReader) As BaseDTO Implements IParser.PopulateDTO
        If IsDBNull(reader.GetInt32(ord_portee)) Then
            Dim prs_serpent As New SerpentParser
            prs_serpent.PopulateOrdinals(reader)
            Return CType(prs_serpent.PopulateDTO(reader), SerpentDTO)
        Else
            Dim prs_chien As New ChienParser
            prs_chien.PopulateOrdinals(reader)
            Return CType(prs_chien.PopulateDTO(reader), ChienDTO)
        End If
        Return Nothing
    End Function
 
    Public Sub PopulateOrdinals(reader As System.Data.SqlClient.SqlDataReader) Implements IParser.PopulateOrdinals
        reader.GetOrdinal("age")
        reader.GetOrdinal("nom")
        reader.GetOrdinal("portee")
    End Sub
End Class
 
Public Class SerpentParser
    Implements IParser
 
    Private ord_age, ord_nom, ord_mue As Integer
 
    Public Function PopulateDTO(reader As System.Data.SqlClient.SqlDataReader) As BaseDTO Implements IParser.PopulateDTO
        Return New SerpentDTO(reader.GetInt32(ord_age), reader.GetString(ord_nom), reader.GetInt32(ord_mue))
    End Function
 
    Public Sub PopulateOrdinals(reader As System.Data.SqlClient.SqlDataReader) Implements IParser.PopulateOrdinals
        ord_age = reader.GetOrdinal("age")
        ord_nom = reader.GetOrdinal("nom")
        ord_mue = reader.GetOrdinal("mue")
    End Sub
End Class
 
Public Class ChienParser
    Implements IParser
 
    Private ord_age, ord_nom, ord_portee As Integer
 
    Public Function PopulateDTO(reader As System.Data.SqlClient.SqlDataReader) As BaseDTO Implements IParser.PopulateDTO
        Return New ChienDTO(reader.GetInt32(ord_age), reader.GetString(ord_nom), reader.GetInt32(ord_portee))
    End Function
 
    Public Sub PopulateOrdinals(reader As System.Data.SqlClient.SqlDataReader) Implements IParser.PopulateOrdinals
        ord_age = reader.GetOrdinal("age")
        ord_nom = reader.GetOrdinal("nom")
        ord_portee = reader.GetOrdinal("portee")
    End Sub
End Class

Alors déjà là, j'ai un doute. Aurais-je dû faire hériter les class SerpentParser et ChienParser de AnimalParser ?

Viennent ensuite le tour des POCO's.

A priori, j'écrirai celui pour Animal comme ceci :

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
Public Class AnimalPOCO
 
    Public Property DTO As AnimalDTO
 
    Public Sub New(dto As AnimalDTO)
        Me.DTO = dto
    End Sub
 
    Public Sub SaveAnimal()
 
    End Sub
 
    Public Sub DeleteAnimal()
 
    End Sub
 
    Public Sub FetchAnimal()
 
    End Sub
 
    Public Sub FetchAnimalByName()
 
    End Sub
End Class

Et ensuite, je bloque... Rien qu'à l'idée du constructeur de ChienPOCO, je cale. Le constructeur de ChienPOCO va demander un objet de type ChienDTO en paramètre. Mais ce même constructeur doit passer un AnimalDTO au constructeur de sa classe de base.

Autant pour une classe "normale", je pense avoir bien pigé (si mes DTO's sont corrects), autant pour un poco, cale méchamment.

Et j'avoue même avoir du mal à exprimer sur quoi je bloque...

Quelqu'un aurait-il l'amabilité de prendre 5 minutes pour compléter l'exemple et fournir les classes POCO correctes ? J'ai tenté de trouvé des exemples sur la toile mais je ne trouve que des trucs en rapport avec EF4.

[Sankasssss]

Bonsoir,

J'ai vraiment du mal avec cette architecture DTO / POCO dès lors je ne sais pas juger sur le bien fondé de ta pratique de celle-ci mais je vais quand même essayer de répondre sur la logique :

Alors déjà là, j'ai un doute. Aurais-je dû faire hériter les class SerpentParser et ChienParser de AnimalParser ?

ça aurait été effectivement judicieux afin de ne pas ré-écrire les variables et la méthode PopulateOrdinals

Et ensuite, je bloque... Rien qu'à l'idée du constructeur de ChienPOCO, je cale. Le constructeur de ChienPOCO va demander un objet de type ChienDTO en paramètre. Mais ce même constructeur doit passer un AnimalDTO au constructeur de sa classe de base.

Je ne vois pas où se trouve le problème, le passage d'un chienDTO vers un animalDTO pourra se faire sans soucis puisque chienDTO hérite de animalDTO

[Kropernic]

Au niveau des parsers, au départ, pour rester dans la suite logique, j'ai voulu utiliser l'héritage, si ma classe SerpentParser hérite de AnimalParser, elle va hériter aussi de ord_portee non ? Or cette classe n'en a cure.

Maintenant, ord_portee n'est dans AnimalParser que pour déterminer quel type instancier.
N.B. : A noter que j'ai remarqué que je devais caster en AnimalDTO et non en ChienDTO et SerpentDTO dans la fonction PopulateDTO de AnimalParser.

Pour le poco, c'est comme tu le dis. Un pote dans le trajet de retour en train m'a expliquer le bazar et ça passe mieux.

Mais le fait de filer un objet qui n'est pas du "bon" type me dérange encore un peu quand même. Mais je crois que c'est juste une question d'habitude.

Je vais retravailler les classes de mon vrai projet demain et je donnerai un p'tit feedback (je sens pointer le billet de blog^^).

[DotNetMatt]

Pourquoi est-ce qu'AnimalParser possède ord_portee ? Il devrait avoir la même "tête" qu'AnimalDTO, à savoir juste faire le travail lié aux propriétés Age et Nom.

[Kropernic]

Pourquoi est-ce qu'AnimalParser possède ord_portee ? Il devrait avoir la même "tête" qu'AnimalDTO, à savoir juste faire le travail lié aux propriétés Age et Nom.

C'est parce que je "triche" dans sa fonction PopulateDTO histoire de savoir à quel type d'objet correspond la ligne dans le datareader.

Au niveau DB, pour modéliser cela, j'aurais également trois tables.
Une table Animal(ani_id, ani_age, ani_nom), une table Chien(ani_id, chi_portee) et une table serpent(ani_id,ser_mue).

Dans la méthode AnimalPOCO.FetchAnimal(), je récupère donc des animaux mais pour éviter devoir faire un accès db à chaque fois que je veux utiliser un animal en tant que chien ou serpent, la procédure stockée utilisée renverra toutes les colonnes nécessaires à la construction d'un chien ou d'un serpent. Et donc, dans AnimalParser.PopulateDTO, j'instancie directement le bon type d'objet tout en renvoyant le type d'objet parent.

C'est pas bon ?

[rv26t]

C'est parce que je "triche" dans sa fonction PopulateDTO histoire de savoir à quel type d'objet correspond la ligne dans le datareader.

Au niveau DB, pour modéliser cela, j'aurais également trois tables.
Une table Animal(ani_id, ani_age, ani_nom), une table Chien(ani_id, chi_portee) et une table serpent(ani_id,ser_mue).

Dans la méthode AnimalPOCO.FetchAnimal(), je récupère donc des animaux mais pour éviter devoir faire un accès db à chaque fois que je veux utiliser un animal en tant que chien ou serpent, la procédure stockée utilisée renverra toutes les colonnes nécessaires à la construction d'un chien ou d'un serpent. Et donc, dans AnimalParser.PopulateDTO, j'instancie directement le bon type d'objet tout en renvoyant le type d'objet parent.

C'est pas bon ?

Dans la procédure stockée vous devez effectivement ramenez toutes les colonnes nécessaires. Et dans l'exemple d'héritage des parser que je vous ai donné, cela doit fonctionner. (sans tricher)

Par contre dans la partie sauvegarde il faudra décomposer par partie de table. (dans vos faux POCO) [Edit] correction erreur inattention[/Edit]

[rv26t]

Bonsoir,

J'ai vraiment du mal avec cette architecture DTO / POCO dès lors je ne sais pas juger sur le bien fondé de ta pratique de celle-ci mais je vais quand même essayer de répondre sur la logique :

Alors déjà là, j'ai un doute. Aurais-je dû faire hériter les class SerpentParser et ChienParser de AnimalParser ?

ça aurait été effectivement judicieux afin de ne pas ré-écrire les variables et la méthode PopulateOrdinals

Je suis d'accord, même si ce n'est peut-être pas forcement évident à mettre en oeuvre.

Et ensuite, je bloque... Rien qu'à l'idée du constructeur de ChienPOCO, je cale. Le constructeur de ChienPOCO va demander un objet de type ChienDTO en paramètre. Mais ce même constructeur doit passer un AnimalDTO au constructeur de sa classe de base.

Je ne vois pas où se trouve le problème, le passage d'un chienDTO vers un animalDTO pourra se faire sans soucis puisque chienDTO hérite de animalDTO

Le souci ne se situe pas au niveau de l'héritage mais au fait qu'il ne doit pas y avoir de méthodes de persistance dans les POCO
Seulement de la logique de contrôle, et de la logique métier.

Après cela ne géne pas au niveau de l'héritage.
L'héritage au niveau propriétés DTO se situe dans la partie définition des DTO.
A mon avis il ne faut pas refaire cette partie héritage dans les POCO (sinon à quoi sert l'héritage puisque c'est pour éviter de réécrire les parties communes)
Les POCO recoivent une propriété adapté à leurs types de traitement, ce sont leurs méthodes qui sont surchargé pour éviter de réécrire les parties méthodes communes.

[rv26t]

J'ai rapidement repris ton code, je ne suis pas sur pour les reader, mais c'est pour essayer de situer le principe.

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
Public Class BaseDTO
    Public Property IsNew As Boolean
End Class
 
Public Class AnimalDTO
    Inherits BaseDTO
    Public Sub New()
        Me.Age = 0
        Me.Nom = ""
    End Sub
 
    Public Property Age As Integer
    Public Property Nom As String
End Class
 
Public Class SerpentDTO
    Inherits AnimalDTO
 
    Public Sub New()
        MyBase.New()
        Me.NombreMue = 0
    End Sub
 
    Public Property NombreMue As Integer
End Class
 
Public Class ChienDTO
    Inherits AnimalDTO
 
    Public Sub New()
        MyBase.New()
        Me.NombrePortee = 0
    End Sub
 
    Public Property NombrePortee As Integer
End Class

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
Public Interface IParser
    Sub PopulateOrdinals(ByVal reader As SqlClient.SqlDataReader)
    Function PopulateDTO(ByVal reader As SqlClient.SqlDataReader) As BaseDTO
End Interface
 
Public Class AnimalParser
    Implements IParser
 
    Private ord_age, ord_nom As Integer
 
    Public Function PopulateDTO(ByVal reader As System.Data.SqlClient.SqlDataReader) As BaseDTO Implements IParser.PopulateDTO
        Dim prs_Animal As New AnimalDTO()
        If Not IsDBNull(reader.GetInt32(ord_age)) Then prs_Animal.Age = reader.GetInt32(ord_age)
        If Not IsDBNull(reader.GetInt32(ord_nom)) Then prs_Animal.Nom = reader.GetInt32(ord_nom)
        prs_Animal.IsNew = False
        Return prs_Animal
    End Function
 
    Public Sub PopulateOrdinals(ByVal reader As System.Data.SqlClient.SqlDataReader) Implements IParser.PopulateOrdinals
        reader.GetOrdinal("age")
        reader.GetOrdinal("nom")
    End Sub
End Class
 
Public Class SerpentParser
    Inherits AnimalParser
 
    Private ord_mue As Integer
 
    Public Overloads Function PopulateDTO(ByVal reader As System.Data.SqlClient.SqlDataReader) As BaseDTO
        Dim prs_Serpent As New SerpentDTO
        Dim prs_Animal As AnimalDTO = MyBase.PopulateDTO(reader)
        prs_Serpent.Nom = prs_Animal.Nom
        prs_Serpent.Age = prs_Animal.Age
        If Not IsDBNull(reader.GetInt32(ord_mue)) Then prs_Serpent.NombreMue = reader.GetInt32(ord_mue)
        Return prs_Serpent
    End Function
 
    Public Overloads Sub PopulateOrdinals(ByVal reader As System.Data.SqlClient.SqlDataReader)
        MyBase.PopulateOrdinals(reader)
        ord_mue = reader.GetOrdinal("mue")
    End Sub
End Class
 
Public Class ChienParser
    Inherits AnimalParser
 
    Private ord_portee As Integer
 
    Public Overloads Function PopulateDTO(ByVal reader As System.Data.SqlClient.SqlDataReader) As BaseDTO
        Dim prs_Chien As New ChienDTO
        Dim prs_Animal As AnimalDTO = MyBase.PopulateDTO(reader)
        prs_Chien.Nom = prs_Animal.Nom
        prs_Chien.Age = prs_Animal.Age
        If Not IsDBNull(reader.GetInt32(ord_portee)) Then prs_Chien.NombrePortee = reader.GetInt32(ord_portee)
        Return prs_Chien
    End Function
 
    Public Overloads Sub PopulateOrdinals(ByVal reader As System.Data.SqlClient.SqlDataReader)
        MyBase.PopulateOrdinals(reader)
        ord_portee = reader.GetOrdinal("portee")
    End Sub
End Class

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
Public Class AnimalPOCO
 
    'Public  Property DTO As AnimalDTO
    Public Sub New()
    end Sub
    'Public Sub New(ByVal UnAge As Integer, ByVal UnNom As String)
    '    Me.DTO.Age = UnAge
    '    Me.DTO.Nom = UnNom
    'End Sub
    'Public Sub New(ByVal dto As AnimalDTO)
    '    Me.DTO = dto
    'End Sub
 
    Public Function ControleAge(ByVal age As Integer) As Boolean
        If age < 0 Then Return False Else Return True
    End Function
 
End Class
 
Public Class SerpentPOCO
    Inherits AnimalPOCO
 
    Public Property DTO As SerpentDTO
 
    Public Sub New(ByVal dto As SerpentDTO)
        MyBase.new()
        Me.DTO = dto
    End Sub
 
    Public Overloads Function ControleAge(ByVal age As Integer) As Boolean
        If Not MyBase.ControleAge(age) Or age > 20 Then Return False Else Return True
    End Function
 
End Class
 
Public Class ChienPOCO
    Inherits AnimalPOCO
 
    Public Property DTO As ChienDTO
 
    Public Sub New(ByVal dto As ChienDTO)
        Me.DTO = dto
    End Sub
 
    Public Overloads Function ControleAge(ByVal age As Integer) As Boolean
        If Not MyBase.ControleAge(age) Or age > 27 Then Return False Else Return True
    End Function
 
End Class

Pour cette dernière partie, je suis moins sur, il faudrait surement plus décomposer les méthodes contrôle pour pouvoir les redéfinir plus finement si d'autre héritage se font (par type de serpent par exemple)

[Kropernic]

Le souci ne se situe pas au niveau de l'héritage mais au fait qu'il ne doit pas y avoir de méthodes de persistance dans les POCO
Seulement de la logique de contrôle, et de la logique métier.

Arf oui c'est vrai. Ce juste que je ne sais pas comment s'appelle le type d'objet que j'utilise... Du coup, à défaut de trouver mieux et je les nomme ainsi. Mais c'est vrai, ce ne sont pas des POCO stricto sensus.

Tant qu'il n'y a pas d'héritage (et encore, ça cloche surement juste pcq j'suis un noob en POO), avec la logique de persistance, c'est quand même super pratique à utiliser.

[rv26t]

Pour compléter mon exemple précédant en décomposant finement les méthodes de contrôles.

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
Public Class SerpentPOCO
    Inherits AnimalPOCO
 
    Public Property DTO As SerpentDTO
 
    Public Sub New(ByVal dto As SerpentDTO)
        Me.DTO = dto
    End Sub
 
    Public Overloads Function ControleAgeMin(ByVal age As Integer) As Boolean
        Return MyBase.ControleAgeMin(age)
    End Function
 
    Public Function ControleAgeMax(ByVal age As String)
        If age > 20 Then Return False Else Return True
    End Function
 
End Class
 
Public Class SerpentASonettePOCO
    Inherits AnimalPOCO
 
    Public Property DTO As SerpentDTO
 
    Public Sub New(ByVal dto As SerpentDTO)
        Me.DTO = dto
    End Sub
 
    Public Overloads Function ControleAgeMin(ByVal age As Integer) As Boolean
        Return MyBase.ControleAgeMin(age)
    End Function
 
    Public Overloads Function ControleAgeMax(ByVal age As String)
        If age > 18 Then Return False Else Return True
    End Function
 
End Class

Tant qu'il n'y a pas d'héritage (et encore, ça cloche surement juste pcq j'suis un noob en POO), avec la logique de persistance, c'est quand même super pratique à utiliser.

C'est ce que j'indique sur mon post6. C'est pas forcement évident à mettre en oeuvre avec l'héritage pour les parser.

[Kropernic]

Oui mais au final, pour les parsers, avec l'utilisation de l'interface pour garantir les 2 méthodes indispensable, ça marche encore pas mal je pense.

Mon gros souci ce situait au niveau de "mes POCO's" (qui n'en sont donc pas ^^) car j'ai encore des soucis avec la notion de polymorphisme.

[Sankasssss]

Le souci ne se situe pas au niveau de l'héritage mais au fait qu'il ne doit pas y avoir de méthodes de persistance dans les POCO
Seulement de la logique de contrôle, et de la logique métier.

Après cela ne géne pas au niveau de l'héritage.

Ca prouve ma méconnaissance de cette pratique que j'ai du mal à assimiler malgré la lecture d'article.
Mais à force de vous lire, je suis sur que j'en verrai l'avantage.
Je compte bien ouvrir une discussion comparant la technique que j'utilise actuellement à celle-ci pour voir les avantages d'une par rapport à l'autre.

[rv26t]

Ca prouve ma méconnaissance de cette pratique que j'ai du mal à assimiler malgré la lecture d'article.
Mais à force de vous lire, je suis sur que j'en verrai l'avantage.

En fait c'est partie de ces tutos
- High Performance Data Access Layer Architecture Part 1
- High Performance Data Access Layer Architecture Part 2
- High Performance Data Access Layer Architecture Part 3
et
Quelle est la différence entre un DTO et un POCO ?

Je compte bien ouvrir une discussion comparant la technique que j'utilise actuellement à celle-ci pour voir les avantages d'une par rapport à l'autre.

[rv26t]

Et ensuite, je bloque... Rien qu'à l'idée du constructeur de ChienPOCO, je cale. Le constructeur de ChienPOCO va demander un objet de type ChienDTO en paramètre. Mais ce même constructeur doit passer un AnimalDTO au constructeur de sa classe de base.

Autant pour une classe "normale", je pense avoir bien pigé (si mes DTO's sont corrects), autant pour un poco, cale méchamment.

Et j'avoue même avoir du mal à exprimer sur quoi je bloque...

Par contre pour la partie concernant la sauvegarde dans la base de données, cela pose un problème
Le problème est : que l'on a 2 éléments d'héritage(DTO et Méthodes), et VB ne permet d'hériter que d'une seule classe.

C'est cela qui vous bloque et que vous n'arriviez pas à exprimer.

[Edit]Regroupement messages héritage pour éviter d'être éparpillé.
Pour palier l'absence d'héritage multiple il faut compléter le dto de base defini dans la classe de base AnimalsCDD (je ne vois pas d'autre solution)

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
Public Class AnimalsCDD ' CDD : Controleur de donnes
    Public DTO As AnimalDTO
    Public Sub New()
    End Sub
    Public Sub SaveAnimal()
        ' sauvegarde dans la table Animal
'...
    End Sub
End Class
 
Public Class SerpentCDD
    Inherits AnimalsCDD
    Public Sub New()
        MyBase.new()
    End Sub
    Public Overloads Sub SaveAnimal(ByVal DTO As SerpentDTO)
        MyBase.DTO.Nom = DTO.Nom
        MyBase.DTO.Age = DTO.Age
        MyBase.SaveAnimal() ' alors qu'il suffirait d'écrire quleque chose comme MyBase.SaveAnimal(mybase.DTO) qui remplacerai les 3 lignes
        ' sauvegarde dans la table serpent
'...
    End Sub
End Class