IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

EDI Delphi Discussion :

XE5- comment paramétrer Delphi pour que le code des évenements que génèré Delphi s'ajoute à la fin du fichier


Sujet :

EDI Delphi

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre averti
    Inscrit en
    Avril 2006
    Messages
    17
    Détails du profil
    Informations forums :
    Inscription : Avril 2006
    Messages : 17
    Par défaut XE5- comment paramétrer Delphi pour que le code des évenements que génèré Delphi s'ajoute à la fin du fichier
    Bonjour,
    tout est dans l'intitulé.

    En effet, XE5 ajoutes les événements un peu bizarrement au milieu du code source déjà écrit.

    comme je place souvent un petit commentaire au dessus des fonction/procedure, Delphi colle le code entre mon commentaire et la déclaration de la fonction. Du coup, mon commentaire déjà dans le code se retrouve juste au dessus du code de la nouvelle fonction.

    Ex :

    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
    == avant ==
    //-------------------------------------------------------------
    // analyse les différences entre la base théorique et la base réelle
    procedure TFS03.FindDifferences;
    const
    ..etc
     
    == Après == double click sur un bouton pour générer le code
    //-------------------------------------------------------------
    // analyse les différences entre la base théorique te la base réelle
    procedure TFS03.Button1Click(Sender: TObject);
    begin
     
    end;
     
    procedure TFS03.FindDifferences;
    const
    Voila, mon commentaire de la fonction FindDifferences() se retrouve au dessus du clic du bouton !

    Merci pour vos lumières, car j'ai beau chercher dans les options de Delphi, je ne trouve rien qui traite de ce sujet

  2. #2
    Rédacteur/Modérateur
    Avatar de Andnotor
    Inscrit en
    Septembre 2008
    Messages
    5 943
    Détails du profil
    Informations personnelles :
    Localisation : Autre

    Informations forums :
    Inscription : Septembre 2008
    Messages : 5 943
    Par défaut
    La génération du code (Ctrl+Shift+C) place/trie les procédures/fonctions dans l'ordre alphabétique. Si tu ne veux pas que le commentaire "bouge", il faut le mettre après la déclaration :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    procedure TForm1.Proc;
    //Mon commentaire
    begin
    end;
    Pas d'option pour cela (enfin à ma connaissance)...

  3. #3
    Membre éprouvé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Août 2012
    Messages
    92
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Industrie

    Informations forums :
    Inscription : Août 2012
    Messages : 92
    Par défaut
    autre solution : mettre le commentaire au niveau de la déclaration de la fonction dans des balises.
    2 avantages :
    1 - le commentaire apparait lorsque la souris est au dessus du nom de la fonction
    2 - pour la doc, les commentaires sont repris

  4. #4
    Membre averti
    Inscrit en
    Avril 2006
    Messages
    17
    Détails du profil
    Informations forums :
    Inscription : Avril 2006
    Messages : 17
    Par défaut
    Bof bof.

    Au niveau de la déclaration, c'est bien s'il n'y a qu'une ligne de commentaire, mais parfois il y en a plusieurs.

    Je suis sur un projet de migration avec reprise de beaucoup de fonction, c'est déjà un boulot énorme alors je n'ai pas envie d'avoir en plus tous les commentaires à revoir.

    Ce qui est pénible aussi, c'est que lorsque je travaille sur une nouvelle function j'ai besoin d'aller ailleurs dans l'unité. un petit Ctrl + Fin me ramène directement dans le code de ma fonction sur laquelle je travaille (enfin en D6 puisque le code s'ajoute à la fin). La, avec XE5, il faut reprendre la souris ou recherche depuis la déclaration, c'est de la perte de temps inutile.

    D'autant plus que j'essaye d'organiser le code avec les OnCreate en premier suis du OnShow puis OnClose, et ensuite les autres éventements. La Delphi colle tout n'importe où n'importe comment.

    Franchement, je ne comprends pas pourquoi, le code ne va pas se mettre à la fin, quel est l’intérêt? Il y a en surement un ou une sorte de logique, elle m’échappe.

  5. #5
    Membre Expert
    Avatar de Charly910
    Homme Profil pro
    Ingénieur TP
    Inscrit en
    Décembre 2006
    Messages
    2 523
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur TP
    Secteur : Bâtiment Travaux Publics

    Informations forums :
    Inscription : Décembre 2006
    Messages : 2 523
    Par défaut
    Bonjour,

    +1

    Dans D7 le nouveau code se plaçait à la fin de l'unité. C'était beaucoup plus pratique pour s'y retrouver pendant le codage de l'appli. Après on pouvait toujours réorganiser si on le souhaitait (grouper par type de procédures ou fonctions ce qui est différent de l'ordre alphabétique !)

    Comme quoi la sophistication n'est pas toujours une bonne chose.

    Mais on ne peut pas arrêter le progrès !

    A+

    Charly

  6. #6
    Membre éprouvé
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Août 2012
    Messages
    92
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Industrie

    Informations forums :
    Inscription : Août 2012
    Messages : 92
    Par défaut
    perso j'utilise énormément les signets pour la navigation dans un fichier.
    lorsqu'il n'y a pas de signet, la fenêtre structure ou le cnpack, permet un positionnement très rapide dans la fonction désirée

  7. #7
    Membre extrêmement actif
    Avatar de skywaukers
    Homme Profil pro
    Directeur de projet
    Inscrit en
    Juin 2005
    Messages
    1 219
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Charente (Poitou Charente)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2005
    Messages : 1 219
    Par défaut
    ok, l'ajout de la nouvelle procédure à la fin est pratique pour la retrouver quand on sait que c'est la dernière ajoutée... Quand on en a ensuite ajoutée une poignée d'autre elle se retrouve noyée sans logique (justement) au beau milieu du source.
    Un classement alphabétique est au contraire un classement qui répond à une logique, ce n'est pas mis "n'importe où, n'importe comment". Et lors d'une recherche "manuelle" le classement alphabétique est quand même ce qu'il y a de plus pratique.
    Ensuite contrairement à ce que j'ai pu lire plus haut, les raccourcis de navigation existe toujorus dans les dernières versions de Delphi (ctrl + maj + fleche haute (ou basse) pour basculer de la déclaration à l'implémentation).

    Par contre effectivement je trouve également il est regrettable que les commentaires placés juste avant une méthode ne soient pas reconnus comme en faisant parti lors de l'ajout d'une nouvelle méthode par l'IDE, cela éviterait que la nouvelle méthode se retrouve entre le commentaire éxistant d'une autre méthode et son début.

    Si Thierry Laborde passe dans le coin ce serait sympa qu'il remonte cela chez Embarcadero, à mon avis ça ne doit pas être très compliquer à régler et effectivement ça simplifierait la vie.

    @++
    Dany

  8. #8
    Membre confirmé
    Profil pro
    Inscrit en
    Décembre 2004
    Messages
    228
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Décembre 2004
    Messages : 228
    Par défaut
    +1 dès que la procédure est créée, je la déplace de suite

  9. #9
    Rédacteur/Modérateur

    Avatar de SergioMaster
    Homme Profil pro
    Développeur informatique retraité
    Inscrit en
    Janvier 2007
    Messages
    15 663
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 69
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations professionnelles :
    Activité : Développeur informatique retraité
    Secteur : Industrie

    Informations forums :
    Inscription : Janvier 2007
    Messages : 15 663
    Billets dans le blog
    65
    Par défaut
    Pour ce qui est des commentaires , j'utilise les régions .
    avec XE4 , en tout cas , ils restent bien accrochés (enfin jusqu'à présent)

    par exemple :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
     
    {$REGION 'Documentation'}
    {*------------------------------------------------------------------------------
      Création de la Forme
        - Lier l'évenement onclick du BrowseBtn du style
    ------------------------------------------------------------------------------*}
    {$ENDREGION}
    procedure TForm3.FormCreate(Sender: TObject);
    begin
     MonLabel.Text:='Sélectionnez un répertoire';
     MonLabel.StylesData['BrowseBtn.OnClick'] := TValue.From<TNotifyEvent>(Button3Click);
    end;
    pour cela , j'utilise un template de code
    {$REGION 'Documentation'}
    {*------------------------------------------------------------------------------
    |
    %BEGINPARAMLIST%@param %PARAMNAME% ParameterDescription
    %ENDPARAMLIST%
    ------------------------------------------------------------------------------*}
    {$ENDREGION}

  10. #10
    Expert éminent
    Avatar de ShaiLeTroll
    Homme Profil pro
    Développeur C++\Delphi
    Inscrit en
    Juillet 2006
    Messages
    14 101
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Seine Saint Denis (Île de France)

    Informations professionnelles :
    Activité : Développeur C++\Delphi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juillet 2006
    Messages : 14 101
    Par défaut
    En XE2, je viens de tester car cela m'intéresse aussi {$REGION 'Documentation'} ne fonctionne pas !

    J'ai une méthode Add,
    j'ajoute la méthode Aad et le commentaire se retrouve au dessus de Aad !

    En XE2, mieux vaut mettre la documentation dans l'interface par exemple
    Certe c'est très encombrant, on voit moins facilement la gueule de la classe si l'on documente beaucoup mais le CTRL ESPACE ou CTRL ALT H fournisse la documentation en live de son propre code !

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
        /// <summary>Indique la connexion en cours sur l'un des Schémas de la Base de Données xxx </summary>
        property Connection: TxxxDBConnection read GetConnection write SetConnection;
        /// <summary>Nom de la Table associée à cette entité DB xxx </summary>
        property TableName: string read GetTableName;
        /// <summary>Nombre de propriétés présentes dans l'entité DB xxx</summary>
        property PropertyCount: Integer read GetPropertyCount;
    Exemple de code "encombré" par la documentation

    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
      /// <summary>interface d'un générateur de Requête SQL gérant des clés primaires auto-incrémentées</summary>
      ISLTDBQuerySQLIdentityGenerator = interface(ISLTDBQuerySQLGenerator)
        ['{D5543140-FECB-4FC8-8238-FEE76A6E5515}']
     
        /// <summary>Génère et Prépare le SQL INSERT</summary>
        /// <param name="ATableName">Nom de la table concernée par l'insertion</param>
        /// <param name="AFieldValueNames">Nom des champs de la table pour lesquels seront insérés des valeurs dans la DB</param>
        /// <param name="AParamValueNames">Noms des paramètres dont les valeurs seront insérées dans la DB. L'ordre des nom de paramètres AParamValueNames doit être le même pour les types dans AParamValueDataTypes pour générer une clause VALUES correcte</param>
        /// <param name="AParamValueDataTypes">Type de données des paramètres dont les valeurs seront insérées dans la DB. L'ordre des types de paramètres AParamValueDataTypes doit être le même que les noms présents dans AParamValueNames pour générer une clause VALUES correcte</param>
        /// <param name="AIdentityFieldName">Nom du Champ utilisé comme Identité (assimable à Clé Primaire AutoIncrémentée) dont la valeur peut-être fournie ou récupérée</param>
        /// <param name="AIdentityFormula">Formule de l'Identité. Doit se conformer à la syntaxe du SQL de la DB ciblée. ISLTDBQuerySQLGeneratorSequenceManager fournit les instructions nécessaires pour obtenir cette formule SQL tout en conservant un code d'appel générique et indépendant de la DB ciblée.
        /// <para>Cela peut contenir le nom d'un paramètre présent dans AParamValueNames, sa valeur sera utilisée y compris le variant Null,</para>
        /// <para>cela peut contenir aussi le mot clé NULL qui sera utilisée comme une formule injecté directement dans le SQL sans passer par un Bind,</para>
        /// <para>cela peut évidemment contenir une formule comme l'appel à une procédure stockée ou l'utilisation d'une séquence.</para></param>
        function InsertPrepare(const ATableName: string; const AFieldValueNames: array of string; const AParamValueNames: array of string; const AParamValueDataTypes: array of TFieldType; const AIdentityFieldName: string; const AIdentityFormula: string): Boolean;
     
        /// <summary>Execute le SQL INSERT préparé</summary>
        /// <param name="AParamValueNames">Noms des paramètres dont les valeurs seront insérées dans la DB. L'ordre des nom de paramètres AParamValueNames doit être le même pour les valeurs dans AParamValues</param>
        /// <param name="AParamValues">Valeurs des paramètres qui seront insérées dans la DB. L'ordre des valeurs de paramètres AParamValues doit être le même que les noms présents dans AParamValueNames</param>
        function InsertExecute(const AParamValueNames: array of string; const AParamValues: array of Variant): TSLTDBQuerySQLGeneratorInsertedIdentity;
     
        /// <summary>Génère et Prépare le SQL UPDATE</summary>
        /// <param name="ATableName">Nom de la table concernée par la mise à jour</param>
        /// <param name="AFieldValueNames">Nom des champs de la table qui dont les valeurs seront modifiés dans la DB</param>
        /// <param name="AParamValueNames">Noms des paramètres dont les valeurs seront modifiées dans la DB. L'ordre des nom de paramètres AParamValueNames doit être le même pour les types dans AParamValueDataTypes pour générer une clause SET correcte</param>
        /// <param name="AParamValueDataTypes">Type de données des paramètres dont les valeurs seront modifiées dans la DB. L'ordre des types de paramètres AParamValueDataTypes doit être le même que les noms présents dans AParamValueNames pour générer une clause SET correcte</param>
        /// <param name="AIdentityFieldName">Nom du Champ utilisé comme Identité (assimable à Clé Primaire AutoIncrémentée) dont la valeur sera utilisée comme critère de mise à jour dans le WHERE</param>
        function UpdatePrepare(const ATableName: string; const AFieldValueNames: array of string; const AParamValueNames: array of string; const AParamValueDataTypes: array of TFieldType; const AIdentityFieldName: string): Boolean;
     
        /// <summary>Execute le SQL UPDATE préparé</summary>
        /// <param name="AParamValueNames">Noms des paramètres dont les valeurs seront modifiées dans la DB. L'ordre des nom de paramètres AParamValueNames doit être le même pour les valeurs dans AParamValues</param>
        /// <param name="AParamValues">Valeurs des paramètres qui seront modifiées dans la DB. L'ordre des valeurs de paramètres AParamValues doit être le même que les noms présents dans AParamValueNames</param>
        function UpdateExecute(const AParamValueNames: array of string; const AParamValues: array of Variant): Boolean;
     
        /// <summary>Génère et Prépare le SQL DELETE</summary>
        /// <param name="ATableName">Nom de la table concernée par la supression</param>
        /// <param name="AIdentityFieldName">Nom du champ utilisé comme clé primaire et critère de suppression</param>
        /// <param name="AIdentityParamName">Nom du paramètre utilisé comme clé primaire et critère de suppression</param>
        /// <param name="AIdentityParamType">Type du paramètre utilisé comme clé primaire et critère de suppression, principalement ftInteger ou ftLargeInt</param>
        function DeletePrepare(const ATableName: string; const AIdentityFieldName: string; const AIdentityParamName: string; const AIdentityParamType: TFieldType): Boolean;
     
        /// <summary>Execute le SQL UPDATE DELETE</summary>
        /// <param name="AIdentityParamName">Nom du paramètre utilisé comme clé primaire et critère de suppression</param>
        /// <param name="AIdentityParamValue">Valeur du paramètre utilisé comme clé primaire et critère de suppression</param>
        function DeleteExecute(const AIdentityParamName: string; const AIdentityParamValue: Variant): Boolean;
      end;
     
      /// <summary>interface donnant accès à une potentielle gestion des séquences d'un générateur de Requête SQL gérant des clés primaires auto-incrémentées</summary>
      ISLTDBQuerySQLGeneratorSequenceManager = interface
        ['{8D666D45-1818-4330-8D4E-BBC63F2521D7}']
        /// <summary>construit un fragment de SQL contenant l'appel à une Séquence</summary>
        /// <param name="ASequenceName">Noms dde la séquence dont l'on souhaite récupérer la valeur suivante</param>
        /// <remarks>Un module métier utilisant ISLTDBQuerySQLIdentityGenerator.InsertPrepare ne connait pas forcément le type de la DB exploitée, il ne peut donc pas fournir le contenu SQL de AIdentityFormula adapté à sa DB, BuildFormulaFromSequenceName permet de conserver un code d'appel générique tout en s'adaptant aux différentes variantes syntaxiques gérés par les interpréteurs SQL.</remarks>
        function BuildFormulaFromSequenceName(const ASequenceName: string): string;
      end;
    Images attachées Images attachées  
    Aide via F1 - FAQ - Guide du développeur Delphi devant un problème - Pensez-y !
    Attention Troll Méchant !
    "Quand un homme a faim, mieux vaut lui apprendre à pêcher que de lui donner un poisson" Confucius
    Mieux vaut se taire et paraître idiot, Que l'ouvrir et de le confirmer !
    L'ignorance n'excuse pas la médiocrité !

    L'expérience, c'est le nom que chacun donne à ses erreurs. (Oscar Wilde)
    Il faut avoir le courage de se tromper et d'apprendre de ses erreurs

  11. #11
    Rédacteur/Modérateur
    Avatar de Andnotor
    Inscrit en
    Septembre 2008
    Messages
    5 943
    Détails du profil
    Informations personnelles :
    Localisation : Autre

    Informations forums :
    Inscription : Septembre 2008
    Messages : 5 943
    Par défaut
    L'idéal ne serait ni à la fin, ni par ordre alphabétique, mais dans l'ordre de la déclaration d'interface

    (Et une commande style formatage de code mais uniquement pour le tri)

  12. #12
    Expert éminent
    Avatar de ShaiLeTroll
    Homme Profil pro
    Développeur C++\Delphi
    Inscrit en
    Juillet 2006
    Messages
    14 101
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Seine Saint Denis (Île de France)

    Informations professionnelles :
    Activité : Développeur C++\Delphi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juillet 2006
    Messages : 14 101
    Par défaut
    Personnellement, en D7, j'avais une ordre logique dans la partie implémentation

    Create\Destroy
    Méthodes genre Singleton ou Execute (si existe)
    Méthodes publiques dans l'ordre de déclaration
    Méthodes privées ou protégées dans l'ordre de déclaration

    Pratique que j'ai continué en C++Builder 2007 et C++XE3 puisque je n'ai pas trouvé l'équivalent du CTRL+ALT+C
    Evidemment, je parle des classes écrites, pour les TForm, j'étais moins rigoureux puisque le code intelligent est vite séparé dans un ViewAdapter ou Controler le tout utilisant des Objets Business ou Entity


    J'ai abandonné sous Delphi XE2, laissant l'ordre Alpha (qui peut faire n'importe quoi si l'on déplace les fonctions)
    Aide via F1 - FAQ - Guide du développeur Delphi devant un problème - Pensez-y !
    Attention Troll Méchant !
    "Quand un homme a faim, mieux vaut lui apprendre à pêcher que de lui donner un poisson" Confucius
    Mieux vaut se taire et paraître idiot, Que l'ouvrir et de le confirmer !
    L'ignorance n'excuse pas la médiocrité !

    L'expérience, c'est le nom que chacun donne à ses erreurs. (Oscar Wilde)
    Il faut avoir le courage de se tromper et d'apprendre de ses erreurs

  13. #13
    Expert éminent
    Avatar de ShaiLeTroll
    Homme Profil pro
    Développeur C++\Delphi
    Inscrit en
    Juillet 2006
    Messages
    14 101
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : France, Seine Saint Denis (Île de France)

    Informations professionnelles :
    Activité : Développeur C++\Delphi
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Juillet 2006
    Messages : 14 101
    Par défaut
    Ce n'est pas le même problème mais c'est la même fonctionnalité

    Je suis sous XE2 et je ne me rappelle pas de ce problème sous D7

    J'ai un objet ancêtre qui contient des accesseurs protégés (le code en XE2 est proche de celui que j'avais en D7 : que l'on trouve Là pour l'ancêtre - [BDD] Séparation de couche de données et Là pour un objet métier Pointeur de Méthode et RTTI )

    J'ai des objets métiers qui héritent de l'objet ancêtre, je vous épargne les détails !
    C'est TEpcPersistant.GetData\SetData en D7
    Oui, j'abuse des propriétés avec spécificateur d'index !


    Mon problème c'est que si je fais CTRL + MAJ + C,
    Il va me générer les accesseurs des propriétés publiées de la persistance métier alors que TOUS les accesseurs sont déclarés dans l'ancêtre !


    L'option "Finir les propriétés incomplètes de la page Outils > Options > Explorateur" qui détermine si l'achèvement de classe termine les déclarations de propriétés n'a pas d'effet sur la génération des accesseurs !

    Heureusement, j'ai prévu un générateur de code (structure en XML, génération d'un PAS, SQL de création et PAS\DFM basique) pour créer les objets métiers c'est un code qui évoluera peu, mais c'est pas pratique !
    Toute la partie business sera séparée dans une autre unité pour ne pas encombrer l'unité Entité, surtout que la couche business est différente selon le métier cible, il y a des éléments communs mais certaines manipulations sont possibles pour les uns et pas pour les autres, de même que la présentation ne prend pas le même Axe selon le métier



    Pour les curieux !

    Le Code de l'ancêtre, la partie des accesseurs communs

    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
      TxxxDBEntity = class(TPersistent)
      ...
        // Accesseurs - Type de propriétés simples
        function GetIntegerPropByIndex(PropertyIndex: Integer): Integer;
        procedure SetIntegerPropByIndex(PropertyIndex: Integer; const Value: Integer);
        function GetStringPropByIndex(PropertyIndex: Integer): string;
        procedure SetStringPropByIndex(PropertyIndex: Integer; const Value: string);
        function GetDoublePropByIndex(PropertyIndex: Integer): Double;
        procedure SetDoublePropByIndex(PropertyIndex: Integer; const Value: Double);
        function GetDateTimePropByIndex(PropertyIndex: Integer): TDateTime;
        procedure SetDateTimePropByIndex(PropertyIndex: Integer; const Value: TDateTime);
        function GetBooleanPropByIndex(PropertyIndex: Integer): Boolean;
        procedure SetBooleanPropByIndex(PropertyIndex: Integer; const Value: Boolean);
     
        // Accesseurs - Type de propriétés acceptant la valeur nulle
        function GetNullableIntegerPropByIndex(PropertyIndex: Integer): IxxxDBEntityNullableInteger;
        function GetNullableStringPropByIndex(PropertyIndex: Integer): IxxxDBEntityNullableString;
        function GetNullableDoublePropByIndex(PropertyIndex: Integer): IxxxDBEntityNullableDouble;
        function GetNullableDateTimePropByIndex(PropertyIndex: Integer): IxxxDBEntityNullableDateTime;
     
        // Accesseurs - Type de propriétés spéciales
        function GetAutoIncrementValuePropByIndex(PropertyIndex: Integer): IxxxDBEntityAutoIncrementValue;
        function GetActiveNumberValuePropByIndex(PropertyIndex: Integer): IxxxDBEntityActiveNumberValue;
        function GetExternalAutoIncrementValuePropByIndex(PropertyIndex: Integer): IxxxDBEntityExternalAutoIncrementValue;
    Un exemple d'objet métier héritant de l'ancêtre

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
      TxxxPalier = class(TxxxDBEntity)
      ...
      published
        // Propriétés
        property PalierID: IxxxDBEntityAutoIncrementValue index TProperties.pPalierID read GetAutoIncrementValuePropByIndex;
        property PalierNumero: IxxxDBEntityActiveNumberValue index TProperties.pPalierNumero read GetActiveNumberValuePropByIndex;
        property BorneBasse: Double index TProperties.pBorneBasse read GetDoublePropByIndex write SetDoublePropByIndex;
        property BorneBasseIncluse: Boolean index TProperties.pBorneBasseIncluse read GetBooleanPropByIndex write SetBooleanPropByIndex;
        property BorneHaute: IxxxDBEntityNullableDouble index TProperties.pBorneHaute read GetNullableDoublePropByIndex;
    Après le CTRL + ALT + C

    voici le bordel dans l'objet métier qui duplique les méthodes dans son corps alors qu'elle existe dans l'ancêtre

    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
      TxxxPrimePalier = class(TxxxDBEntity)
      ...
        function GetActiveNumberValuePropByIndex(
          const Index: Integer): IxxxDBEntityActiveNumberValue;
        function GetAutoIncrementValuePropByIndex(
          const Index: Integer): IxxxDBEntityAutoIncrementValue;
        function GetBooleanPropByIndex(const Index: Integer): Boolean;
        function GetDoublePropByIndex(const Index: Integer): Double;
        function GetNullableDoublePropByIndex(
          const Index: Integer): IxxxDBEntityNullableDouble;
        procedure SetBooleanPropByIndex(const Index: Integer; const Value: Boolean);
        procedure SetDoublePropByIndex(const Index: Integer; const Value: Double);
      published
        // Propriétés
        property PalierID: IxxxDBEntityAutoIncrementValue index TProperties.pPalierID read GetAutoIncrementValuePropByIndex;
        property PalierNumero...
    Aide via F1 - FAQ - Guide du développeur Delphi devant un problème - Pensez-y !
    Attention Troll Méchant !
    "Quand un homme a faim, mieux vaut lui apprendre à pêcher que de lui donner un poisson" Confucius
    Mieux vaut se taire et paraître idiot, Que l'ouvrir et de le confirmer !
    L'ignorance n'excuse pas la médiocrité !

    L'expérience, c'est le nom que chacun donne à ses erreurs. (Oscar Wilde)
    Il faut avoir le courage de se tromper et d'apprendre de ses erreurs

Discussions similaires

  1. Réponses: 2
    Dernier message: 26/02/2014, 15h22
  2. Réponses: 0
    Dernier message: 24/02/2014, 11h18
  3. Réponses: 8
    Dernier message: 27/06/2008, 18h33
  4. Réponses: 1
    Dernier message: 11/06/2008, 13h30
  5. Réponses: 0
    Dernier message: 27/10/2007, 16h13

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo