Opérations (model)

De Wiki1000
(Différences entre les versions)
(Nouvelle page : ===Définition des opération=== ===Type d'opération=== ====Procédures==== ====Fonctions==== ====Règles==== ====Constructeurs==== ===Signature et paramètre d'opération=== ===Pas...)
 
(Ecrire le code métier.)
 
(4 révisions intermédiaires par un utilisateur sont masquées)
Ligne 1 : Ligne 1 :
===Définition des opération===
+
===Introduction===
===Type d'opération===
+
Les classes exposent leurs services à travers des opérations.
====Procédures====
+
Le langage 1000 étant dérivé de Pascal Objet il existe plusiers types d’opérations.
====Fonctions====
+
*Une fonction est une opération qui renvoie une valeur quand elle est exécutée.
====Règles====
+
*Une procédure est une opération qui ne renvoie pas de valeur.
====Constructeurs====
+
*Un constructeur est une opération qui crée un objet.
===Signature et paramètre d'opération===
+
===Passage de paramètre===
+
===Visibilité des opérations===
+
====Opération privé====
+
====Opération protégée====
+
====Opération publique====
+
===Surcharge des opérations===
+
====Opération virtuelle====
+
====Opération surchargées====
+
====Règles de surcharge====
+
===Opération de classe===
+
  
 +
===Définition d’opération===
 +
Cliquez droit sur la classe sélectionnée et puis sur la fonction Ajouter une opération du menu contextuel.
 +
 +
Vous accédez à la fenêtre suivante :
  
 +
{{#images:image1.png|dsm/modele/operation}}
 +
 +
*Signature
 +
:La signature définit les paramètres de l’opération. Le combo box permet de sélectionner une signature d’une méthode virtuelle héritée afin de s’assurer que l’opération de surcharge sera possible.
 +
*Surcharge de
 +
:La surcharge définit que cette opération est une surcharge d’une opération virtuelle héritée. Pour que cette opération soit possible il faut :
 +
:*Que l’opération héritée soit définie comme virtuelle.
 +
:*Que la signature de cette opération soit absolument identique à la signature de l’opération héritée.
 +
*Publique
 +
:Une opération publique est utilisable par toutes les classes ayant une visibilité sur cette classe.
 +
*Protégé
 +
:Une opération protégée est utilisable par une classe descendante ou par une extension de cette classe.
 +
*Privé
 +
:Une opération privée n’est utilisable que par cette classe.
 +
*Virtuelle
 +
:Une opération virtuelle est surchargeable par une classe dérivée ou par une extension.
 +
*Méthode de classe
 +
:Une méthode de classe est une méthode accessible au niveau de la classe.
 +
 +
Cliquez sur le bouton OK pour valider l’opération. Vous retrouvez la définition de la fonction dans l'arbre de conception, dans la section Opérations de la classe.
 +
 +
===Ecrire le code métier.===
 +
Le code métier implémente le fonctionnel de l'opération et il est exécuté chaque fois que l’opération est appelée. Pour écrire un bloc de code cliquez droit sur la fonction ou la procédure sélectionnée et ensuite cliquez sur Modifier le code du menu contextuel.
 +
 +
[[tip|Pour les opérations simples vous pouvez aussi définir directement le code métier lors de la définition de l'opération.}}
 +
 +
{{#images:image3.png|dsm/modele/operation}}
 +
 +
Vous pouvez éditer le code métier dans la partie droite de l’écran.
 +
 +
{{#images:image2.png|dsm/modele/operation}}
 +
 +
{{info|Pour plus d'informations sur l'éditeur de code consulter la page [[Editeur_de_code_(concepteur)|Editeur de code]]}}
 +
 +
===Signature===
 +
A la déclaration d'une procédure ou d'une fonction, vous spécifiez son nom, la liste des paramètres et, dans le cas d'une fonction, le type de la valeur renvoyée.
 +
 +
Cette partie de la déclaration est appelée la « signature » de l’opération.
 +
 +
====Signature de procédure====
 +
La signature d'une procédure a la forme :
 +
 +
<source lang='delphi'>Procedure nomProcedure(listeParamètres);</source>
 +
 +
La liste des paramètres est une suite de déclarations de paramètres séparées par des points-virgules et spécifie le nombre, l'ordre et le type des paramètres qui doivent être transmis à la fonction lors de son appel.
 +
 +
A la déclaration d'un paramètre, vous spécifiez la déclaration optionnelle « var » (qualificateur), le nom du paramètre suivi du symbole deux points et son type.
 +
 +
Dans le cas des paramètres objets et liste d’objet le type du paramètre indiqué dans la signature est utilisé par le compilateur pour déterminer la classe de l’objet référencé par le paramètre.
 +
 +
Exemple
 +
<source lang='delphi'>Procedure CreerCumulPremierePeriode(pOidPeriode :String ; pOidCumulANouveauCompte :String);</source>
 +
 +
Si une procédure n'utilise aucun paramètre, omettez dans sa déclaration la liste d'identificateurs et les parenthèses.
 +
 +
Exemple
 +
 +
<source lang='delphi'>Procedure CreerCumulANouveauSuivants;</source>
 +
 +
====Signature de fonction====
 +
Une signature de fonction est similaire à la signature d'une procédure mais elle spécifie le type de la valeur renvoyée.
 +
 +
<source lang='delphi'>function nomFonction(listeParamètres):TypeRetour;</source>
 +
 +
A l’intérieur du code d’une fonction la valeur de retour est référencée par la variable « Result ».
 +
 +
Exemple
 +
<source lang='delphi'>
 +
Function OidEstEnListe(aOid :String ; listeOid :TStringList) :Boolean ;
 +
Begin
 +
Result := listOid.IndexOf(aOid)<>-1 ;
 +
End ;
 +
</source>
 +
 +
===Passage de paramètres===
 +
On peut identifier plusieurs types de transmission de paramètres :
 +
 +
*paramètres transmis par valeur.
 +
*paramètres transmis par référence.
 +
*paramètres objet.
 +
*paramètres liste d’objets.
 +
 +
====Paramètres transmis par valeur====
 +
Les paramètres transmis par valeur se comportent comme des variables locales qui sont initialisées avec la valeur transmise à l'appel de la fonction. Si vous transmettez une variable comme paramètre par valeur, la fonction en crée une copie et les modifications apportées à la copie sont sans effet sur la variable d'origine et sont perdues quand l'exécution du programme revient à l'appel de la fonction.
 +
 +
Si la valeur est modifiée dans l’opération, la valeur modifiée n’est pas récupérée à la sortie de l’opération.
 +
 +
Exemple
 +
<source lang='delphi'>
 +
Function foo(i:Integer; const s:string):Integer ;
 +
begin
 +
// i est un paramètre par valeur
 +
// s est un paramètre par valeur
 +
end;
 +
</source>
 +
 +
====Paramètres transmis par référence====
 +
Un paramètre transmis par référence est précédé de la déclaration « var » et se comporte, lui, comme un pointeur et non comme une copie. Les modifications apportées aux paramètres dans le corps de la fonction sont conservées lorsque l'exécution du programme revient à l'appel de la fonction et que le nom du paramètre est hors de portée.
 +
 +
Si la valeur est modifiée dans l’opération, la valeur modifiée est récupérée à la sortie de l’opération.
 +
 +
Exemple
 +
<source lang='delphi'>
 +
Function foo(i:Integer; var s:string):Integer ;
 +
begin
 +
// i est un paramètre par valeur
 +
// s est un paramètre par référence
 +
end;
 +
</source>
 +
 +
Les paramètres valeurs sont transmis par valeur alors que les paramètres variables sont transmis par adresse. Ce comportement est mis en évidence par l'exemple suivant.
 +
 +
Exemple
 +
<source lang='delphi'>
 +
function DoubleParValeur(X : Integer) : Integer ; // X est un paramètre valeur
 +
begin
 +
X := X * 2 ;
 +
Result := X ;
 +
end;
 +
 +
function DoubleParAdresse(var X : Integer) : Integer ; // X est un paramètre variable
 +
begin
 +
X := X * 2 ;
 +
Result := X ;
 +
end ;
 +
</source>
 +
 +
Ces deux fonctions renvoient le même résultat, mais seule la seconde (DoubleParAdresse) peut modifier la valeur de la variable qui lui est transmise.
 +
 +
{{info|Il n'y a pas de message d'erreur à la compilation ou à l'exécution si vous modifiez un paramètre transmis par valeur, le paramètre est effectivement modifié durant l'exécution de la fonction mais sa valeur finale n'est pas retournée à l'appelant.
 +
 +
Les paramètres de type simple passés par référence sont en fait passés par copie; leur valeur finale étant recopié dans la variable correspondante de l'appelant.}}
 +
 +
====Paramètres objet====
 +
Les instances d'un type classe sont appelées des objets. Les paramètres de type objet sont toujours transmis par référence, le paramètre contenant l'adresse d’une instance de l'objet. Le code de la procédure peut accéder aux attributs de l'objet en lecture ou modification ou appeler les méthodes de l’objet.
 +
 +
Le compilateur utilise le type du paramètre déclaré dans la signature pour déterminer la classe de l’objet.
 +
 +
Exemple
 +
<source lang='delphi'>
 +
Procedure MaProcedure(pEcriture : Tecriture) ;
 +
Begin
 +
// Le compilateur utilise Tecriture comme classe de l’objet
 +
// numero est un attribut de la classe Tecriture
 +
//
 +
// L’objet ecriture est effectivement modifié
 +
// bien que le paramètre soit passé par valeur.
 +
//
 +
PEcriture.numero := 123 ;
 +
End;
 +
 +
Procedure MaProcedure(var pEcriture : Tecriture) ;
 +
Begin
 +
// Le paramètre est passé par référence
 +
// l’objet instancié sera retrourné au code appelant.
 +
//
 +
pEcriture := ClassManager.CreateInstance(‘Tecriture’) ;
 +
pEcriture.numero := 123 ;
 +
End;
 +
</source>
 +
 +
Il est possible de déclarer un type générique « TdbObject » comme type d’un paramètre objet. Dans ce cas il n’est pas possible d’utiliser directement la notation pointée.
 +
 +
Exemple
 +
<source lang='delphi'>
 +
Procedure MaProcedure(pObjet : TdbObject) ;
 +
Begin
 +
// Le compilateur ne connaît pas la classe de l’objet
 +
// Cette ligne provoque une erreur de compilation
 +
//
 +
pObjet.numero := 123 ;
 +
//
 +
// TdbObjet dispose de fonctions pour accéder aux attributs
 +
//
 +
pObjet.PropAsVariant[‘numero’] := 123 ;
 +
End ;
 +
</source>
 +
 +
====Paramètres ensemble d'objets====
 +
Il est possible de passer des listes et curseurs d'objets en paramètre d'une opération.
 +
Le compilateur utilise le type du paramètre déclaré dans la signature pour déterminer la classe de l’objet. Pour indiquer qu’il s’agit d’une liste d’objet il faut post fixer le type par le mot clé « List »; pour un curseur le post fixer par « Cursor »
 +
 +
Exemple
 +
<source lang='delphi'>Procedure MaProcedure(vListeEcritures : TEcritureList);</source>
 +
 +
Le compilateur traite vListeEcritures comme étant une liste contenant des objets TEcriture, sans avoir besoin de déclarer autrement le type TEcritureList.
 +
 +
====Fonction retournant un objet====
 +
Les fonctions peuvent retourner un objet, le type du résultat déclaré dans la signature doit être dans ce cas une classe.
 +
 +
Exemple
 +
 +
<source lang='delphi'>
 +
Function _DonnerCompteAuxiliaire(pCompteGeneral :TCompteGeneral) : TCompteAuxiliaire ;
 +
begin
 +
Result := CreateObject('TCompteAuxiliare') ;
 +
...
 +
end;
 +
</source>
 +
 +
Le résultat est un objet de type TCompteAuxiliaire qu'on a créé dans la fonction _DonnerCompteAuxiliaire
 +
 +
===Surcharge d’opération===
 +
Il est possible de re-déclarer une opération héritée dans une classe dérivée. C'est ce que l'on appelle la surcharge. Les opérations surchargées constituent une manière efficace d'implémenter un comportement polymorphique.
 +
 +
Seule les opérations déclarée virtuelles peuvent être surchargées.
 +
 +
Si une déclaration d’opération spécifie le même identificateur d’opération et la même signature de paramètres qu'une opération héritée, la nouvelle déclaration surcharge l’opération.
 +
 +
A l’intérieur d’une opération surchargée vous pouvez appeler le code surchargé grâce au mot clé « inherited ». L’appel à « inherited » doit passer les paramètres nécessaires à la procédure surchargée.
 +
 +
Exemple
 +
<source lang='delphi'>
 +
Function MyOverrideFunction(const iParam :string) :string ;
 +
Begin
 +
Result := inherited(iParam) ;
 +
If Result = ‘Spécial’ then Result := ‘Spécialité’ ;
 +
End ;
 +
</source>
 +
 +
{{Footer|Modèle}}
 
[[category:Modèle]]
 
[[category:Modèle]]

Version actuelle en date du 13 juillet 2011 à 13:39

Sommaire

Introduction

Les classes exposent leurs services à travers des opérations. Le langage 1000 étant dérivé de Pascal Objet il existe plusiers types d’opérations.

  • Une fonction est une opération qui renvoie une valeur quand elle est exécutée.
  • Une procédure est une opération qui ne renvoie pas de valeur.
  • Un constructeur est une opération qui crée un objet.

Définition d’opération

Cliquez droit sur la classe sélectionnée et puis sur la fonction Ajouter une opération du menu contextuel.

Vous accédez à la fenêtre suivante :

image1.png

  • Signature
La signature définit les paramètres de l’opération. Le combo box permet de sélectionner une signature d’une méthode virtuelle héritée afin de s’assurer que l’opération de surcharge sera possible.
  • Surcharge de
La surcharge définit que cette opération est une surcharge d’une opération virtuelle héritée. Pour que cette opération soit possible il faut :
  • Que l’opération héritée soit définie comme virtuelle.
  • Que la signature de cette opération soit absolument identique à la signature de l’opération héritée.
  • Publique
Une opération publique est utilisable par toutes les classes ayant une visibilité sur cette classe.
  • Protégé
Une opération protégée est utilisable par une classe descendante ou par une extension de cette classe.
  • Privé
Une opération privée n’est utilisable que par cette classe.
  • Virtuelle
Une opération virtuelle est surchargeable par une classe dérivée ou par une extension.
  • Méthode de classe
Une méthode de classe est une méthode accessible au niveau de la classe.

Cliquez sur le bouton OK pour valider l’opération. Vous retrouvez la définition de la fonction dans l'arbre de conception, dans la section Opérations de la classe.

Ecrire le code métier.

Le code métier implémente le fonctionnel de l'opération et il est exécuté chaque fois que l’opération est appelée. Pour écrire un bloc de code cliquez droit sur la fonction ou la procédure sélectionnée et ensuite cliquez sur Modifier le code du menu contextuel.

[[tip|Pour les opérations simples vous pouvez aussi définir directement le code métier lors de la définition de l'opération.}}

image3.png

Vous pouvez éditer le code métier dans la partie droite de l’écran.

image2.png

Info-20px.png Note : Pour plus d'informations sur l'éditeur de code consulter la page Editeur de code

Signature

A la déclaration d'une procédure ou d'une fonction, vous spécifiez son nom, la liste des paramètres et, dans le cas d'une fonction, le type de la valeur renvoyée.

Cette partie de la déclaration est appelée la « signature » de l’opération.

Signature de procédure

La signature d'une procédure a la forme :

Procedure nomProcedure(listeParamètres);

La liste des paramètres est une suite de déclarations de paramètres séparées par des points-virgules et spécifie le nombre, l'ordre et le type des paramètres qui doivent être transmis à la fonction lors de son appel.

A la déclaration d'un paramètre, vous spécifiez la déclaration optionnelle « var » (qualificateur), le nom du paramètre suivi du symbole deux points et son type.

Dans le cas des paramètres objets et liste d’objet le type du paramètre indiqué dans la signature est utilisé par le compilateur pour déterminer la classe de l’objet référencé par le paramètre.

Exemple

Procedure CreerCumulPremierePeriode(pOidPeriode :String ; pOidCumulANouveauCompte :String);

Si une procédure n'utilise aucun paramètre, omettez dans sa déclaration la liste d'identificateurs et les parenthèses.

Exemple

Procedure CreerCumulANouveauSuivants;

Signature de fonction

Une signature de fonction est similaire à la signature d'une procédure mais elle spécifie le type de la valeur renvoyée.

function nomFonction(listeParamètres):TypeRetour;

A l’intérieur du code d’une fonction la valeur de retour est référencée par la variable « Result ».

Exemple

Function OidEstEnListe(aOid :String ; listeOid :TStringList) :Boolean ;
Begin
 Result := listOid.IndexOf(aOid)<>-1 ;
End ;

Passage de paramètres

On peut identifier plusieurs types de transmission de paramètres :

  • paramètres transmis par valeur.
  • paramètres transmis par référence.
  • paramètres objet.
  • paramètres liste d’objets.

Paramètres transmis par valeur

Les paramètres transmis par valeur se comportent comme des variables locales qui sont initialisées avec la valeur transmise à l'appel de la fonction. Si vous transmettez une variable comme paramètre par valeur, la fonction en crée une copie et les modifications apportées à la copie sont sans effet sur la variable d'origine et sont perdues quand l'exécution du programme revient à l'appel de la fonction.

Si la valeur est modifiée dans l’opération, la valeur modifiée n’est pas récupérée à la sortie de l’opération.

Exemple

Function foo(i:Integer; const s:string):Integer ;
begin
 // i est un paramètre par valeur
 // s est un paramètre par valeur
end;

Paramètres transmis par référence

Un paramètre transmis par référence est précédé de la déclaration « var » et se comporte, lui, comme un pointeur et non comme une copie. Les modifications apportées aux paramètres dans le corps de la fonction sont conservées lorsque l'exécution du programme revient à l'appel de la fonction et que le nom du paramètre est hors de portée.

Si la valeur est modifiée dans l’opération, la valeur modifiée est récupérée à la sortie de l’opération.

Exemple

Function foo(i:Integer; var s:string):Integer ;
begin
 // i est un paramètre par valeur
 // s est un paramètre par référence
end;

Les paramètres valeurs sont transmis par valeur alors que les paramètres variables sont transmis par adresse. Ce comportement est mis en évidence par l'exemple suivant.

Exemple

function DoubleParValeur(X : Integer) : Integer ; // X est un paramètre valeur
begin
 X := X * 2 ;
 Result := X ;
end;
 
function DoubleParAdresse(var X : Integer) : Integer ; // X est un paramètre variable
begin
 X := X * 2 ;
 Result := X ;
end ;

Ces deux fonctions renvoient le même résultat, mais seule la seconde (DoubleParAdresse) peut modifier la valeur de la variable qui lui est transmise.

Info-20px.png Note : Il n'y a pas de message d'erreur à la compilation ou à l'exécution si vous modifiez un paramètre transmis par valeur, le paramètre est effectivement modifié durant l'exécution de la fonction mais sa valeur finale n'est pas retournée à l'appelant.

Les paramètres de type simple passés par référence sont en fait passés par copie; leur valeur finale étant recopié dans la variable correspondante de l'appelant.

Paramètres objet

Les instances d'un type classe sont appelées des objets. Les paramètres de type objet sont toujours transmis par référence, le paramètre contenant l'adresse d’une instance de l'objet. Le code de la procédure peut accéder aux attributs de l'objet en lecture ou modification ou appeler les méthodes de l’objet.

Le compilateur utilise le type du paramètre déclaré dans la signature pour déterminer la classe de l’objet.

Exemple

Procedure MaProcedure(pEcriture : Tecriture) ;
Begin
 // Le compilateur utilise Tecriture comme classe de l’objet
 // numero est un attribut de la classe Tecriture
 //
 // L’objet ecriture est effectivement modifié
 // bien que le paramètre soit passé par valeur.
 //
 PEcriture.numero := 123 ; 
End;
 
Procedure MaProcedure(var pEcriture : Tecriture) ;
Begin
 // Le paramètre est passé par référence
 // l’objet instancié sera retrourné au code appelant.
 //
 pEcriture := ClassManager.CreateInstance(‘Tecriture’) ;
 pEcriture.numero := 123 ;
End;

Il est possible de déclarer un type générique « TdbObject » comme type d’un paramètre objet. Dans ce cas il n’est pas possible d’utiliser directement la notation pointée.

Exemple

Procedure MaProcedure(pObjet : TdbObject) ;
Begin
 // Le compilateur ne connaît pas la classe de l’objet
 // Cette ligne provoque une erreur de compilation
 //
 pObjet.numero := 123 ; 
 //
 // TdbObjet dispose de fonctions pour accéder aux attributs
 //
 pObjet.PropAsVariant[‘numero’] := 123 ;
End ;

Paramètres ensemble d'objets

Il est possible de passer des listes et curseurs d'objets en paramètre d'une opération. Le compilateur utilise le type du paramètre déclaré dans la signature pour déterminer la classe de l’objet. Pour indiquer qu’il s’agit d’une liste d’objet il faut post fixer le type par le mot clé « List »; pour un curseur le post fixer par « Cursor »

Exemple

Procedure MaProcedure(vListeEcritures : TEcritureList);

Le compilateur traite vListeEcritures comme étant une liste contenant des objets TEcriture, sans avoir besoin de déclarer autrement le type TEcritureList.

Fonction retournant un objet

Les fonctions peuvent retourner un objet, le type du résultat déclaré dans la signature doit être dans ce cas une classe.

Exemple

Function _DonnerCompteAuxiliaire(pCompteGeneral :TCompteGeneral) : TCompteAuxiliaire ;
begin
 Result := CreateObject('TCompteAuxiliare') ;
 ...
end;

Le résultat est un objet de type TCompteAuxiliaire qu'on a créé dans la fonction _DonnerCompteAuxiliaire

Surcharge d’opération

Il est possible de re-déclarer une opération héritée dans une classe dérivée. C'est ce que l'on appelle la surcharge. Les opérations surchargées constituent une manière efficace d'implémenter un comportement polymorphique.

Seule les opérations déclarée virtuelles peuvent être surchargées.

Si une déclaration d’opération spécifie le même identificateur d’opération et la même signature de paramètres qu'une opération héritée, la nouvelle déclaration surcharge l’opération.

A l’intérieur d’une opération surchargée vous pouvez appeler le code surchargé grâce au mot clé « inherited ». L’appel à « inherited » doit passer les paramètres nécessaires à la procédure surchargée.

Exemple

Function MyOverrideFunction(const iParam :string) :string ;
Begin
 Result := inherited(iParam) ;
 If Result = ‘Spécial’ then Result := ‘Spécialité’ ;
End ;

ModèleDéveloppement DSM





Whos here now:   Members 0   Guests 1   Bots & Crawlers 0
 
Outils personnels