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...)
 
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===
+
===Définition d’opération===
−
===Visibilité des opérations===
+
Cliquez droit sur la classe sélectionnée et puis sur la fonction Ajouter une opération du menu contextuel.
−
====Opération privé====
+
−
====Opération protégée====
+
Vous accédez à la fenêtre suivante :
−
====Opération publique====
+
 
−
===Surcharge des opérations===
+
{{#images:image1.png/dsm/modele/operation}}
−
====Opération virtuelle====
+
−
====Opération surchargées====
+
*Signature
−
====Règles de surcharge====
+
: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.
−
===Opération de classe===
+
*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.
 +
 
 +
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.
 +
 
 +
Vous pouvez éditer le code métier dans la partie droite de l’écran.
 +
 
 +
{{#images:image2.png|dsm/modele/operation}}
 +
 +
*Ouvrir, sauvegarder, imprimer
 +
:Ces fonctions agissent sur le contenu de l’éditeur de code.
 +
*Compiler
 +
:Cette fonction permet de compiler le code.
 +
*Validation et compilation (vérification syntaxe).
 +
:Cliquez sur le bouton Compiler. Dans la fenêtre de messages le framework vous indique les erreurs de compilation ou le message «
 +
 
 +
Compilé OK » si le code est correct.
 +
 +
*Enregistrement.
 +
:Cliquez droit sur la fonction ou procédure et cliquez sur Déboguer. Vous accédez à la fenêtre suivante :
 +
 +
Choisir Oui pour enregistrer vos modifications.
 +
 +
Si vous répondez Oui, les modifications effectuées sont conservées et continuent à être exécutées. Si vous répondez Non, les modifications sont annulées et le code revient à l’état antérieur avant le passage en mode édition. Répondre Oui ne signifie pas que le modèle est sauvegardé.
 +
 
 +
===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 », 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
 +
<pre class="wikicode">
 +
Function OidEstEnListe(aOid :String ; listeOid :TStringList) :Boolean ;
 +
Begin
 +
Result := listOid.IndexOf(aOid)<>-1 ;
 +
End ;
 +
</pre>
 +
 
 +
===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 _LettrerReglement(i :Integer) :TLettrage ;
 +
// i est un paramètre par valeur
 +
Procedure InitTypeLot(iType :Integer) ;
 +
// iType est un paramètre par valeur.
 +
 
 +
====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
 +
<pre>
 +
Procedure(var i :Integer) ;
 +
// i est un paramètre variable.
 +
</pre>
 +
 
 +
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
 +
<pre>
 +
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 ;
 +
</pre>
 +
 
 +
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.
 +
 
 +
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.
 +
 
 +
====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
 +
<pre>
 +
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;
 +
</pre>
 +
 
 +
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
 +
<pre>
 +
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 ;
 +
</pre>
 +
 
 +
====Paramètres liste d'objets====
 +
Il est possible de passer des listes 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 ».
 +
 
 +
Exemple
 +
<pre>
 +
Procedure MaProcedure(vListeEcritures : TecritureList) ;
 +
</pre>
 +
 
 +
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
 +
 
 +
<pre>
 +
Function _DonnerCompteAuxiliaire(pCompteGeneral :TCompteGeneral) : TCompteAuxiliaire ;
 +
begin
 +
Result := CreateObject('TCompteAuxiliare') ;
 +
...
 +
end ;
 +
</pre>
 +
 
 +
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
 +
<pre>
 +
Function MyOverrideFunction(const iParam :string) :string ;
 +
Begin
 +
Result := inherited(iParam) ;
 +
If Result = ‘Spécial’ then Result := ‘Spécialité’ ;
 +
End ;
 +
</pre>
  
  
 
[[category:Modèle]]
 
[[category:Modèle]]

Version du 14 juillet 2009 à 09:33

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 :

https://frp.sage.fr/wiki1000/medias/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.

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.

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

image2.png

  • Ouvrir, sauvegarder, imprimer
Ces fonctions agissent sur le contenu de l’éditeur de code.
  • Compiler
Cette fonction permet de compiler le code.
  • Validation et compilation (vérification syntaxe).
Cliquez sur le bouton Compiler. Dans la fenêtre de messages le framework vous indique les erreurs de compilation ou le message « 

Compilé OK » si le code est correct.

  • Enregistrement.
Cliquez droit sur la fonction ou procédure et cliquez sur Déboguer. Vous accédez à la fenêtre suivante :

Choisir Oui pour enregistrer vos modifications. 

Si vous répondez Oui, les modifications effectuées sont conservées et continuent à être exécutées. Si vous répondez Non, les modifications sont annulées et le code revient à l’état antérieur avant le passage en mode édition. Répondre Oui ne signifie pas que le modèle est sauvegardé.

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 », 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 _LettrerReglement(i :Integer) :TLettrage ; 

// i est un paramètre par valeur

Procedure InitTypeLot(iType :Integer) ; 

// iType est un paramètre par valeur.

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 

Procedure(var i :Integer) ;
 // i est un paramètre variable.

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. 

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.

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 liste d'objets

Il est possible de passer des listes 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 ».

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 ;
Récupérée de « https://frp.sage.fr/wiki1000/index.php?title=Op%C3%A9rations_(model)&oldid=594 »
Outils personnels