Opérations (model)

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

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 :

• 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.}}

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

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.

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 ;