Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Zoury
Bonsoir ! :O)
Tu comprends l'anglais ? http://msdn.microsoft.com/vbasic/downloads/2005/tools/refactor/refactorwhitepaper/
Sinon, le refactoring consiste à modifier la structure du code par de petits changements par-ci, par là dans le but de le rendre plus propre, plus performant et/ou plus flexible en y préservant le traitement qui y est effectué.
Un exemple vaut mille mots dans ce cas-ci ... alors supposons les fonctions suivantes (les morceaux de codes qui suivent n'ont pas été testé, ils n'ont font que démontrer le concept) : '*** Private Function ObtenirListeClients(ByVal cn As SqlConnection, _ ByVal nIdEtablissement As Int32, _ ByVal dtDebutPeriode As DateTime, _ ByVal dtFinPeriode As DateTime) As DataSet
Dim cmd As OracleCommand Dim da As OracleDataAdapter Dim p As OracleParameter Dim ds As DataSet
' préparation de la requête cmd = New OracleCommand cmd.Connection = cn cmd.CommandText = "sp_obtenir_liste_clients" cmd.CommandType = CommandType.StoredProcedure
' préparation des paramètres p = New SqlParameter p.ParameterName = "@id_etablissement" p.OracleDbType = SqlDbType.Int p.Direction = ParameterDirection.Input p.Value = nIdEtablissement
p = New SqlParameter p.ParameterName = "@date_debut_periode" p.OracleDbType = SqlDbType.DateTime p.Direction = ParameterDirection.Input p.Value = dtDebutPeriode
p = New SqlParameter p.ParameterName = "@date_fin_periode" p.OracleDbType = SqlDbType.DateTime p.Direction = ParameterDirection.Input p.Value = dtFinPeriode
' initialise les objets retrouvant les données ds = New DataSet da = New OracleDataAdapter(cmd)
' initialise la connexion et exécute la requête da.Fill(ds)
' dispose des ressources non-managées cmd.Dispose() da.Dispose() p.Dispose()
Return ds
End Function
Private Function ObtenirListeEtablissements(ByVal cn As SqlConnection, _ ByVal nIdCompagnie As Int32) As DataSet
Dim cmd As OracleCommand Dim da As OracleDataAdapter Dim p As OracleParameter Dim ds As DataSet
' préparation de la requête cmd = New OracleCommand cmd.Connection = cn cmd.CommandText = "sp_obtenir_liste_client_par_etab" cmd.CommandType = CommandType.StoredProcedure
' préparation des paramètres p = New SqlParameter p.ParameterName = "@id_compagnie" p.OracleDbType = SqlDbType.Int p.Direction = ParameterDirection.Input p.Value = nIdCompagnie
' initialise les objets retrouvant les données ds = New DataSet da = New OracleDataAdapter(cmd)
' initialise la connexion et exécute la requête da.Fill(ds)
' dispose des ressources non-managées cmd.Dispose() da.Dispose() p.Dispose()
Return ds
End Function '***
et bien on pourrait modifier le code un tantinet en implémentant une CreerParametre() ce qui rendrait le code moins redondant <- centralisation. Ainsi si on veut modifier la manière de créer les paramètres, nous n'aurions qu'une seule fonction à modifier et non 4 blocs de code distinct ce qui diminue de beaucoup les risques d'erreurs en plus de raccourcir considérablement la tâche de travail.
Ex : '*** Private Function CreerParametre(ByVal sNomParametre As String, _ ByVal eTypeSql As SqlDbType, _ ByVal eDirection As ParameterDirection, _ ByVal oValue As Object) As SqlParameter
Dim p As SqlParameter
p = New SqlParameter p.ParameterName = sNomParametre p.OracleDbType = eTypeSql p.Direction = eDirection p.Value = oValue
Return p
End Function
Private Function ObtenirListeClients(ByVal cn As SqlConnection, _ ByVal nIdEtablissement As Int32, _ ByVal dtDebutPeriode As DateTime, _ ByVal dtFinPeriode As DateTime, _ ByVal nNbrAchatsMin As Int32) As DataSet
Dim cmd As OracleCommand Dim da As OracleDataAdapter Dim p As OracleParameter Dim ds As DataSet
' préparation de la requête cmd = New OracleCommand cmd.Connection = cn cmd.CommandText = "sp_obtenir_liste_client_par_etab" cmd.CommandType = CommandType.StoredProcedure
' préparation des paramètres p = CreerParametre("@id_etablissement", SqlDbType.Int, ParameterDirection.Input, nIdEtablissement) p = CreerParametre("@date_debut_periode", SqlDbType.DateTime, ParameterDirection.Input, dtDebutPeriode) p = CreerParametre("@date_fin_periode", SqlDbType.DateTime, ParameterDirection.Input, dtFinPeriode) p = CreerParametre("@nbr_achats_min", SqlDbType.DateTime, ParameterDirection.Input, nNbrAchatsMin)
' initialise les objets retrouvant les données ds = New DataSet da = New OracleDataAdapter(cmd)
' initialise la connexion et exécute la requête da.Fill(ds)
' dispose des ressources non-managées cmd.Dispose() da.Dispose() p.Dispose()
Return ds
End Function '***
et voilà, nous venons d'exécuter du "refactoring". Mais ce n'est pas fini ! Nous pourrions continuer encore et encore. :O) Les fonctions sont pratiquement identique, seule les paramètres et le nom de la procédure stockée change.. alors nous pourrions implémenter un méthode AppelerProcedure qui s'occuperait de l'appel à la base de données. Ainsi nous pourrions créer une tonne d'autre méthode permettant de retourné des DataSet en quelques lignes seulement.
Ex : '*** Private Function CreerParametre(ByVal sNomParametre As String, _ ByVal eTypeSql As SqlDbType, _ ByVal eDirection As ParameterDirection, _ ByVal oValue As Object) As SqlParameter
Dim p As SqlParameter
p = New SqlParameter p.ParameterName = sNomParametre p.OracleDbType = eTypeSql p.Direction = eDirection p.Value = oValue
Return p
End Function
Private Function AppelerProcedure(ByVal cn As SqlConnection, _ ByVal sNomProcedure As String, _ ByVal arrParametres As SqlParameter()) As DataSet
Dim cmd As OracleCommand Dim da As OracleDataAdapter Dim p As OracleParameter Dim ds As DataSet
' préparation de la requête cmd = New OracleCommand cmd.Connection = cn cmd.CommandText = sNomProcedure cmd.CommandType = CommandType.StoredProcedure
' préparation des paramètres For Each p In arrParametres cmd.Parameters.Add(p) Next p
' initialise les objets retrouvant les données ds = New DataSet da = New OracleDataAdapter(cmd)
' initialise la connexion et exécute la requête da.Fill(ds)
' dispose des ressources non-managées cmd.Dispose() da.Dispose() p.Dispose()
Return ds
End Function
Private Function ObtenirListeClients(ByVal cn As SqlConnection, _ ByVal nIdEtablissement As Int32, _ ByVal dtDebutPeriode As DateTime, _ ByVal dtFinPeriode As DateTime, _ ByVal nNbrAchatsMin As Int32) As DataSet
On pourrait maintenant penser à diviser ces méthodes par classes distinctes : - une classe AccesDonnees qui contiendrait les méthodes AppelerProcedure() et CreerParametre() (Shared) et qui peut même être réutilisable dans tout tes projets si tu la place dans une DLL. - une classe Client qui contiendrait une méthode ObtenirListe() (Shared). - une classe Etablissement qui contiendrait une méthode ObtenirListe() (Shared).
Et voilà ! J'espère t'avoir éclairé sur ce qu'est le refactoring. C'est une technique très très efficace si appliquée régulièrement (je l'applique personnellement tout le temps...)
-- Cordialement Yanick MVP pour Visual Basic "Etudiant" a écrit dans le message de news:
Bonsoir, pourriez m'expliquer ce qu'est le refactoring merci
Bonsoir ! :O)
Tu comprends l'anglais ?
http://msdn.microsoft.com/vbasic/downloads/2005/tools/refactor/refactorwhitepaper/
Sinon, le refactoring consiste à modifier la structure du code par de petits
changements par-ci, par là dans le but de le rendre plus propre, plus
performant et/ou plus flexible en y préservant le traitement qui y est
effectué.
Un exemple vaut mille mots dans ce cas-ci ... alors supposons les fonctions
suivantes (les morceaux de codes qui suivent n'ont pas été testé, ils n'ont
font que démontrer le concept) :
'***
Private Function ObtenirListeClients(ByVal cn As SqlConnection, _
ByVal
nIdEtablissement As Int32, _
ByVal dtDebutPeriode
As DateTime, _
ByVal dtFinPeriode
As DateTime) As DataSet
Dim cmd As OracleCommand
Dim da As OracleDataAdapter
Dim p As OracleParameter
Dim ds As DataSet
' préparation de la requête
cmd = New OracleCommand
cmd.Connection = cn
cmd.CommandText = "sp_obtenir_liste_clients"
cmd.CommandType = CommandType.StoredProcedure
' préparation des paramètres
p = New SqlParameter
p.ParameterName = "@id_etablissement"
p.OracleDbType = SqlDbType.Int
p.Direction = ParameterDirection.Input
p.Value = nIdEtablissement
p = New SqlParameter
p.ParameterName = "@date_debut_periode"
p.OracleDbType = SqlDbType.DateTime
p.Direction = ParameterDirection.Input
p.Value = dtDebutPeriode
p = New SqlParameter
p.ParameterName = "@date_fin_periode"
p.OracleDbType = SqlDbType.DateTime
p.Direction = ParameterDirection.Input
p.Value = dtFinPeriode
' initialise les objets retrouvant les données
ds = New DataSet
da = New OracleDataAdapter(cmd)
' initialise la connexion et exécute la requête
da.Fill(ds)
' dispose des ressources non-managées
cmd.Dispose()
da.Dispose()
p.Dispose()
Return ds
End Function
Private Function ObtenirListeEtablissements(ByVal cn As SqlConnection, _
ByVal
nIdCompagnie As Int32) As DataSet
Dim cmd As OracleCommand
Dim da As OracleDataAdapter
Dim p As OracleParameter
Dim ds As DataSet
' préparation de la requête
cmd = New OracleCommand
cmd.Connection = cn
cmd.CommandText = "sp_obtenir_liste_client_par_etab"
cmd.CommandType = CommandType.StoredProcedure
' préparation des paramètres
p = New SqlParameter
p.ParameterName = "@id_compagnie"
p.OracleDbType = SqlDbType.Int
p.Direction = ParameterDirection.Input
p.Value = nIdCompagnie
' initialise les objets retrouvant les données
ds = New DataSet
da = New OracleDataAdapter(cmd)
' initialise la connexion et exécute la requête
da.Fill(ds)
' dispose des ressources non-managées
cmd.Dispose()
da.Dispose()
p.Dispose()
Return ds
End Function
'***
et bien on pourrait modifier le code un tantinet en implémentant une
CreerParametre() ce qui rendrait le code moins redondant <- centralisation.
Ainsi si on veut modifier la manière de créer les paramètres, nous n'aurions
qu'une seule fonction à modifier et non 4 blocs de code distinct ce qui
diminue de beaucoup les risques d'erreurs en plus de raccourcir
considérablement la tâche de travail.
Ex :
'***
Private Function CreerParametre(ByVal sNomParametre As String, _
ByVal eTypeSql As
SqlDbType, _
ByVal eDirection As
ParameterDirection, _
ByVal oValue As Object)
As SqlParameter
Dim p As SqlParameter
p = New SqlParameter
p.ParameterName = sNomParametre
p.OracleDbType = eTypeSql
p.Direction = eDirection
p.Value = oValue
Return p
End Function
Private Function ObtenirListeClients(ByVal cn As SqlConnection, _
ByVal
nIdEtablissement As Int32, _
ByVal dtDebutPeriode
As DateTime, _
ByVal dtFinPeriode
As DateTime, _
ByVal nNbrAchatsMin
As Int32) As DataSet
Dim cmd As OracleCommand
Dim da As OracleDataAdapter
Dim p As OracleParameter
Dim ds As DataSet
' préparation de la requête
cmd = New OracleCommand
cmd.Connection = cn
cmd.CommandText = "sp_obtenir_liste_client_par_etab"
cmd.CommandType = CommandType.StoredProcedure
' préparation des paramètres
p = CreerParametre("@id_etablissement", SqlDbType.Int,
ParameterDirection.Input, nIdEtablissement)
p = CreerParametre("@date_debut_periode", SqlDbType.DateTime,
ParameterDirection.Input, dtDebutPeriode)
p = CreerParametre("@date_fin_periode", SqlDbType.DateTime,
ParameterDirection.Input, dtFinPeriode)
p = CreerParametre("@nbr_achats_min", SqlDbType.DateTime,
ParameterDirection.Input, nNbrAchatsMin)
' initialise les objets retrouvant les données
ds = New DataSet
da = New OracleDataAdapter(cmd)
' initialise la connexion et exécute la requête
da.Fill(ds)
' dispose des ressources non-managées
cmd.Dispose()
da.Dispose()
p.Dispose()
Return ds
End Function
'***
et voilà, nous venons d'exécuter du "refactoring".
Mais ce n'est pas fini ! Nous pourrions continuer encore et encore. :O)
Les fonctions sont pratiquement identique, seule les paramètres et le nom de
la procédure stockée change.. alors nous pourrions implémenter un méthode
AppelerProcedure qui s'occuperait de l'appel à la base de données. Ainsi
nous pourrions créer une tonne d'autre méthode permettant de retourné des
DataSet en quelques lignes seulement.
Ex :
'***
Private Function CreerParametre(ByVal sNomParametre As String, _
ByVal eTypeSql As
SqlDbType, _
ByVal eDirection As
ParameterDirection, _
ByVal oValue As Object)
As SqlParameter
Dim p As SqlParameter
p = New SqlParameter
p.ParameterName = sNomParametre
p.OracleDbType = eTypeSql
p.Direction = eDirection
p.Value = oValue
Return p
End Function
Private Function AppelerProcedure(ByVal cn As SqlConnection, _
ByVal sNomProcedure
As String, _
ByVal arrParametres
As SqlParameter()) As DataSet
Dim cmd As OracleCommand
Dim da As OracleDataAdapter
Dim p As OracleParameter
Dim ds As DataSet
' préparation de la requête
cmd = New OracleCommand
cmd.Connection = cn
cmd.CommandText = sNomProcedure
cmd.CommandType = CommandType.StoredProcedure
' préparation des paramètres
For Each p In arrParametres
cmd.Parameters.Add(p)
Next p
' initialise les objets retrouvant les données
ds = New DataSet
da = New OracleDataAdapter(cmd)
' initialise la connexion et exécute la requête
da.Fill(ds)
' dispose des ressources non-managées
cmd.Dispose()
da.Dispose()
p.Dispose()
Return ds
End Function
Private Function ObtenirListeClients(ByVal cn As SqlConnection, _
ByVal
nIdEtablissement As Int32, _
ByVal dtDebutPeriode
As DateTime, _
ByVal dtFinPeriode
As DateTime, _
ByVal nNbrAchatsMin
As Int32) As DataSet
On pourrait maintenant penser à diviser ces méthodes par classes distinctes
:
- une classe AccesDonnees qui contiendrait les méthodes
AppelerProcedure() et CreerParametre() (Shared) et qui peut même être
réutilisable dans tout tes projets si tu la place dans une DLL.
- une classe Client qui contiendrait une méthode ObtenirListe()
(Shared).
- une classe Etablissement qui contiendrait une méthode ObtenirListe()
(Shared).
Et voilà !
J'espère t'avoir éclairé sur ce qu'est le refactoring. C'est une technique
très très efficace si appliquée régulièrement (je l'applique personnellement
tout le temps...)
--
Cordialement
Yanick
MVP pour Visual Basic
"Etudiant" <user@domain.invalid> a écrit dans le message de
news:Or5LAcmVFHA.3076@TK2MSFTNGP12.phx.gbl...
Bonsoir,
pourriez m'expliquer ce qu'est le refactoring
merci
Tu comprends l'anglais ? http://msdn.microsoft.com/vbasic/downloads/2005/tools/refactor/refactorwhitepaper/
Sinon, le refactoring consiste à modifier la structure du code par de petits changements par-ci, par là dans le but de le rendre plus propre, plus performant et/ou plus flexible en y préservant le traitement qui y est effectué.
Un exemple vaut mille mots dans ce cas-ci ... alors supposons les fonctions suivantes (les morceaux de codes qui suivent n'ont pas été testé, ils n'ont font que démontrer le concept) : '*** Private Function ObtenirListeClients(ByVal cn As SqlConnection, _ ByVal nIdEtablissement As Int32, _ ByVal dtDebutPeriode As DateTime, _ ByVal dtFinPeriode As DateTime) As DataSet
Dim cmd As OracleCommand Dim da As OracleDataAdapter Dim p As OracleParameter Dim ds As DataSet
' préparation de la requête cmd = New OracleCommand cmd.Connection = cn cmd.CommandText = "sp_obtenir_liste_clients" cmd.CommandType = CommandType.StoredProcedure
' préparation des paramètres p = New SqlParameter p.ParameterName = "@id_etablissement" p.OracleDbType = SqlDbType.Int p.Direction = ParameterDirection.Input p.Value = nIdEtablissement
p = New SqlParameter p.ParameterName = "@date_debut_periode" p.OracleDbType = SqlDbType.DateTime p.Direction = ParameterDirection.Input p.Value = dtDebutPeriode
p = New SqlParameter p.ParameterName = "@date_fin_periode" p.OracleDbType = SqlDbType.DateTime p.Direction = ParameterDirection.Input p.Value = dtFinPeriode
' initialise les objets retrouvant les données ds = New DataSet da = New OracleDataAdapter(cmd)
' initialise la connexion et exécute la requête da.Fill(ds)
' dispose des ressources non-managées cmd.Dispose() da.Dispose() p.Dispose()
Return ds
End Function
Private Function ObtenirListeEtablissements(ByVal cn As SqlConnection, _ ByVal nIdCompagnie As Int32) As DataSet
Dim cmd As OracleCommand Dim da As OracleDataAdapter Dim p As OracleParameter Dim ds As DataSet
' préparation de la requête cmd = New OracleCommand cmd.Connection = cn cmd.CommandText = "sp_obtenir_liste_client_par_etab" cmd.CommandType = CommandType.StoredProcedure
' préparation des paramètres p = New SqlParameter p.ParameterName = "@id_compagnie" p.OracleDbType = SqlDbType.Int p.Direction = ParameterDirection.Input p.Value = nIdCompagnie
' initialise les objets retrouvant les données ds = New DataSet da = New OracleDataAdapter(cmd)
' initialise la connexion et exécute la requête da.Fill(ds)
' dispose des ressources non-managées cmd.Dispose() da.Dispose() p.Dispose()
Return ds
End Function '***
et bien on pourrait modifier le code un tantinet en implémentant une CreerParametre() ce qui rendrait le code moins redondant <- centralisation. Ainsi si on veut modifier la manière de créer les paramètres, nous n'aurions qu'une seule fonction à modifier et non 4 blocs de code distinct ce qui diminue de beaucoup les risques d'erreurs en plus de raccourcir considérablement la tâche de travail.
Ex : '*** Private Function CreerParametre(ByVal sNomParametre As String, _ ByVal eTypeSql As SqlDbType, _ ByVal eDirection As ParameterDirection, _ ByVal oValue As Object) As SqlParameter
Dim p As SqlParameter
p = New SqlParameter p.ParameterName = sNomParametre p.OracleDbType = eTypeSql p.Direction = eDirection p.Value = oValue
Return p
End Function
Private Function ObtenirListeClients(ByVal cn As SqlConnection, _ ByVal nIdEtablissement As Int32, _ ByVal dtDebutPeriode As DateTime, _ ByVal dtFinPeriode As DateTime, _ ByVal nNbrAchatsMin As Int32) As DataSet
Dim cmd As OracleCommand Dim da As OracleDataAdapter Dim p As OracleParameter Dim ds As DataSet
' préparation de la requête cmd = New OracleCommand cmd.Connection = cn cmd.CommandText = "sp_obtenir_liste_client_par_etab" cmd.CommandType = CommandType.StoredProcedure
' préparation des paramètres p = CreerParametre("@id_etablissement", SqlDbType.Int, ParameterDirection.Input, nIdEtablissement) p = CreerParametre("@date_debut_periode", SqlDbType.DateTime, ParameterDirection.Input, dtDebutPeriode) p = CreerParametre("@date_fin_periode", SqlDbType.DateTime, ParameterDirection.Input, dtFinPeriode) p = CreerParametre("@nbr_achats_min", SqlDbType.DateTime, ParameterDirection.Input, nNbrAchatsMin)
' initialise les objets retrouvant les données ds = New DataSet da = New OracleDataAdapter(cmd)
' initialise la connexion et exécute la requête da.Fill(ds)
' dispose des ressources non-managées cmd.Dispose() da.Dispose() p.Dispose()
Return ds
End Function '***
et voilà, nous venons d'exécuter du "refactoring". Mais ce n'est pas fini ! Nous pourrions continuer encore et encore. :O) Les fonctions sont pratiquement identique, seule les paramètres et le nom de la procédure stockée change.. alors nous pourrions implémenter un méthode AppelerProcedure qui s'occuperait de l'appel à la base de données. Ainsi nous pourrions créer une tonne d'autre méthode permettant de retourné des DataSet en quelques lignes seulement.
Ex : '*** Private Function CreerParametre(ByVal sNomParametre As String, _ ByVal eTypeSql As SqlDbType, _ ByVal eDirection As ParameterDirection, _ ByVal oValue As Object) As SqlParameter
Dim p As SqlParameter
p = New SqlParameter p.ParameterName = sNomParametre p.OracleDbType = eTypeSql p.Direction = eDirection p.Value = oValue
Return p
End Function
Private Function AppelerProcedure(ByVal cn As SqlConnection, _ ByVal sNomProcedure As String, _ ByVal arrParametres As SqlParameter()) As DataSet
Dim cmd As OracleCommand Dim da As OracleDataAdapter Dim p As OracleParameter Dim ds As DataSet
' préparation de la requête cmd = New OracleCommand cmd.Connection = cn cmd.CommandText = sNomProcedure cmd.CommandType = CommandType.StoredProcedure
' préparation des paramètres For Each p In arrParametres cmd.Parameters.Add(p) Next p
' initialise les objets retrouvant les données ds = New DataSet da = New OracleDataAdapter(cmd)
' initialise la connexion et exécute la requête da.Fill(ds)
' dispose des ressources non-managées cmd.Dispose() da.Dispose() p.Dispose()
Return ds
End Function
Private Function ObtenirListeClients(ByVal cn As SqlConnection, _ ByVal nIdEtablissement As Int32, _ ByVal dtDebutPeriode As DateTime, _ ByVal dtFinPeriode As DateTime, _ ByVal nNbrAchatsMin As Int32) As DataSet
On pourrait maintenant penser à diviser ces méthodes par classes distinctes : - une classe AccesDonnees qui contiendrait les méthodes AppelerProcedure() et CreerParametre() (Shared) et qui peut même être réutilisable dans tout tes projets si tu la place dans une DLL. - une classe Client qui contiendrait une méthode ObtenirListe() (Shared). - une classe Etablissement qui contiendrait une méthode ObtenirListe() (Shared).
Et voilà ! J'espère t'avoir éclairé sur ce qu'est le refactoring. C'est une technique très très efficace si appliquée régulièrement (je l'applique personnellement tout le temps...)
-- Cordialement Yanick MVP pour Visual Basic "Etudiant" a écrit dans le message de news:
Bonsoir, pourriez m'expliquer ce qu'est le refactoring merci
Zoury
Oups!.. J'ai oublié d'implémenter ObtenirListeEtablissements() dans le deuxième bloc de code... mais je doute que ça nuise à ta compréhension. ;O)
-- Cordialement Yanick MVP pour Visual Basic
Oups!.. J'ai oublié d'implémenter ObtenirListeEtablissements() dans le
deuxième bloc de code... mais je doute que ça nuise à ta compréhension. ;O)
