Raccourci pour implémenter une interface

**joc02** · 16/12/2016, 10h21

Bonjour,

Auriez-vous un raccourci pour implémenter une interface lorsque je l'a défini dans l'héritage (genre ctrl+shift+c) ?

J'ai regardé ici mais pas vu ce qui m'intéressait : http://docwiki.embarcadero.com/RADSt...oard_Shortcuts

Merci par avance pour vos réponses

**ShaiLeTroll** · 16/12/2016, 11h33

Je ne sais pas si je répond à ta question

Si je dois implémenter une interface, souvent plusieurs classes doivent le faire pour coller à l'architecture de contrat mise en place

je colle tout simplement, tous les méthodes de l'interface dans une section private dédiée et un CTRL+MAJ+C me fourni le corps !
Dans certaines de mes classes, je ne peux pas utiliser "CTRL+MAJ+C" car les getters/setters sont hérités d'un ancêtre et l'EDI ne sait pas gérer cela !

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
private
  { Déclarations privées }
  FField1: string;
  FField2: string;
 
  procedure Get ...
  function Set ...
private
  { Implémentation de ITruc}
  procedure Bidule();
  function Machin(): IChose;
public
  { Déclarations publiques }
  constructor Create(...); override;
  destructor Destroy(); override;
public
  { Méthodes des Classes }
  class procedure Execute(...);
end;

cela peut donner ce genre de code

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
 
  /// <summary>Implémentation abstraite de ISLTPersistentPropertiesData</summary>
  /// <remarks>Objet interne gérant les données des propriétés</remarks>
  TSLTPersistentAbstractPropertiesData = class abstract(TSLTInterfacedObject, ISLTPersistentPropertiesData, ISLTPersistentRTTIAccess)
  protected
    // Types protégés
    type
      PData = ^TData;
      TData = record
        MetaData: ISLTPersistentPropertyMetaData;
        Intf: ISLTPersistentPropertyData;
      end;
  strict private
    // Membres privés
    FMetaData: ISLTPersistentPropertiesMetaData;
    FRTTIAccess: TSLTPersistentRTTIAccess;
    FData: array of TData;
    FDataLock: TSLTReadWriteSynchronizer;
    FDataPropertyIndexNeedResolution: Boolean;
    FFactories: ISLTPersistentFactories;
 
    // Méthodes internes
    function InitializeFromMetaData(const AMetaData: ISLTPersistentPropertiesMetaData): Boolean;
    function IndexOfPropertyName(const PropertyName: string): Integer;
    function IndexOfPropertyIndex(PropertyIndex: Integer): Integer;
    function FindDataByPropertyName(const PropertyName: string): PData;
    function FindDataByPropertyIndex(PropertyIndex: Integer): PData;
    function FindData(Index: Integer): PData;
    function GetPropertyData(AData: PData): ISLTPersistentPropertyData;
  protected
    // Méthodes - Implémentation abstraite de ISLTPersistentPropertiesData
    function PropertyDataIntfFactory(AMetaData: ISLTPersistentPropertyMetaData): ISLTPersistentPropertyData; virtual; abstract;
  protected
    // Accesseurs - Implémentation de ISLTPersistentPropertiesData
    function GetPropertiesMetaData(): ISLTPersistentPropertiesMetaData; virtual;
    procedure SetPropertiesMetaData(const Value: ISLTPersistentPropertiesMetaData); virtual;
    function GetFactories(): ISLTPersistentFactories; virtual;
    procedure SetFactories(const Value: ISLTPersistentFactories); virtual;
    function GetPropertyCount(): Integer;
    function GetProperty(Index: Integer): ISLTPersistentPropertyData;
    function GetPropertyDataByName(const PropertyName: string): ISLTPersistentPropertyData;
    function GetPropertyIndexByName(const PropertyName: string): Integer;
    function GetPropertyDataByIndex(PropertyIndex: Integer): ISLTPersistentPropertyData;
    function GetPropertyNameByIndex(PropertyIndex: Integer): string;
 
    // Propriétés
    // Délégation à une propriété de type classe
    property RTTIAccess: TSLTPersistentRTTIAccess read FRTTIAccess implements ISLTPersistentRTTIAccess;
 
    // Propriétés d'interface redéfinies à usage interne dans les classes héritées
    property Factories: ISLTPersistentFactories read GetFactories;
    property PropertiesMetaData: ISLTPersistentPropertiesMetaData read GetPropertiesMetaData;
  public
    // Constructeurs
    constructor Create(const AController: IInterface = nil); override;
    destructor Destroy(); override;
  end;
 
 
 
  /// <summary>Implémentation abstraite de ISLTPersistentPropertiesData et ISLTPersistentORMEntityDataSetProxy</summary>
  /// <remarks>Objet interne gérant les données des propriétés</remarks>
  TSLTPersistentORMEntityAbstractPropertiesData = class abstract(TSLTPersistentAbstractPropertiesData, ISLTPersistentORMEntityDataSetProxy, ISLTPersistentRTTIAccess)
  strict private
    // Membres privés
    FInternalDataSetProxy: TSLTPersistentORMEntityDataSetProxy;
  protected
    // Délégation à une propriété de type classe
    property InternalDataSetProxy: TSLTPersistentORMEntityDataSetProxy read FInternalDataSetProxy implements ISLTPersistentORMEntityDataSetProxy;
  protected
    // Méthodes à usage interne dans les classes héritées
    function HaveDataSet(): Boolean;
    function FindField(AMetaDeta: ISLTPersistentPropertyMetaData): TField;
    procedure InternalSetPublishedPropertiesContainer(const Value: TObject); virtual; abstract;
    // Gestionnaire d'Evenement
    procedure InternalDataSetProxyChangeEventHandler(Sender: TObject); virtual; abstract;
  protected
    // Accesseurs - Implémentation de ISLTPersistentRTTIAccess
    function GetPublishedPropertiesContainer(): TObject;
    procedure SetPublishedPropertiesContainer(const Value: TObject);
    function GetValue(const PropertyName: string): Variant;
    procedure SetValue(const PropertyName: string; const Value: Variant);
 
  public
    // Constructeurs
    constructor Create(const AController: IInterface = nil); override;
    destructor Destroy(); override;
  end;
 
...
 
 
  /// <summary>Implémentation par défaut de ISLTPersistentPropertiesData et ISLTPersistentSetPropertiesData utilisée par les Ensemble d'Entités ORM</summary>
  TSLTPersistentORMEntitySetPropertiesData = class(TSLTPersistentORMEntityAbstractPropertiesData, ISLTPersistentPropertiesOutsourcedData, ISLTPersistentSetPropertiesData, ISLTPersistentSetCountable, ISLTPersistentLoadStateInspector, ISLTPersistentSetLoadStateInspector)
  strict private
    // Membres privés
    FInternalData: ISLTPersistentSetPropertiesData;
    FLoadedByRecNo: array of Boolean;
    FLoadedAll: Boolean;
    FDataSetRecordCountable: Boolean;
 
    // Méthodes privées - Loaded et RecNo
    procedure CheckLoadedBounds(ARecNo: Integer);
    procedure CheckLoadedAll(ADataSet: TDataSet);
    function GetLoadedByRecNo(ARecNo: Integer): Boolean;
    procedure SetLoadedByRecNo(ARecNo: Integer; const Value: Boolean);
    procedure RemoveLoaded(ARecNo: Integer);
    procedure CheckRecNoIsReliable(ARecNo: Integer);
  public
    // Méthodes - Implémentation tardive de ISLTPersistentPropertiesData
    function PropertyDataIntfFactory(AMetaData: ISLTPersistentPropertyMetaData): ISLTPersistentPropertyData; override;
    // Méthodes - Implémentation tardive de ISLTPersistentRTTIAccess
    procedure InternalSetPublishedPropertiesContainer(const Value: TObject); override;
    // Gestionnaire d'Evenement
    procedure InternalDataSetProxyChangeEventHandler(Sender: TObject); override;
  protected
    // Accesseurs - Implémentation de ISLTPersistentSetPropertiesData
    function GetBoF(): Boolean;
    function GetEoF(): Boolean;
    // Accesseurs - Implémentation de ISLTPersistentPropertiesOutsourcedData et ISLTPersistentSetPropertiesData
    function GetValue(AMetaDeta: ISLTPersistentPropertyMetaData; AOld: Boolean): Variant;
    procedure SetValue(AMetaDeta: ISLTPersistentPropertyMetaData; AOld: Boolean; const Value: Variant);
    function GetChanged(AMetaDeta: ISLTPersistentPropertyMetaData): Boolean;
    procedure SetChanged(AMetaDeta: ISLTPersistentPropertyMetaData; const Value: Boolean);
    function GetChangedModifiable(AMetaDeta: ISLTPersistentPropertyMetaData): Boolean;
    // Accesseurs - Implémentation de ISLTPersistentSetCountable
    function GetPersistentCount(): Integer;
    function GetPersistentActiveNumber(): Integer;
    // Accesseurs - Ré-Implémentation de ISLTPersistentPropertiesData
    procedure SetPropertiesMetaData(const Value: ISLTPersistentPropertiesMetaData); override;
    procedure SetFactories(const Value: ISLTPersistentFactories); override;
    // Accesseurs - Implémentation tardive de ISLTPersistentLoadStateInspector
    function GetLoaded(): Boolean;
    procedure SetLoaded(const Value: Boolean);
  public
    // Méthodes - Implémentation de ISLTPersistentSetPropertiesData
    procedure First();
    procedure Next();
    function IsEmpty(): Boolean;
    procedure Append();
    function AppendData(AData: ISLTPersistentPropertiesData): Boolean;
    procedure Remove();
    procedure Clear();
    // Méthodes - Implémentation de ISLTPersistentSetLoadStateInspector
    procedure SetAllLoaded(const Value: Boolean);
  public
    // Constructeurs
    constructor Create(const AController: IInterface = nil); override;
 end;

**joc02** · 16/12/2016, 11h36

En fait c'est surtout pour éviter le copier coller des méthodes de l'interface dans la classe.

**ShaiLeTroll** · 16/12/2016, 11h43

Je comprends bien mais si tu connais une astuce, je suis preneur !

Quand tu développes un ActiveX, lors modifications du TLB sont reportés dans l'interface mais aussi dans la CoClasse
Preuve que l'IDE peut le faire !

Pour une interface simple, je ne connais pas !

Dans le code assez extrême, j'ai des implémentations tardives,

A implémente I1 et I2 mais ne contient que les méthodes de I1 (A est une class abstract qui empêche sont instanciation)
B hérité de A implémente I3 et I4 mais ne contient que les méthodes de I3 et peut commencer à gérer I1 (idem B est class abstract)
Enfin C1 et C2 qui hérité de B, implémente respectivement I5a et I5b et fournisse enfin toutes les implémentations manquantes de I1 à I4 ...

Dans la plupart des cas, l'interface est implémenté à 100% par une classe, et une auto génération serait pratique

**guillemouze** · 16/12/2016, 11h54

Envoyé par joc02

En fait c'est surtout pour éviter le copier coller des méthodes de l'interface dans la classe.

ctrl+espace

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
type
  TMaClasse = class(TObject, IMonItf)
    |<curseur ici, ctrl+espace>
  end;

**joc02** · 16/12/2016, 11h58

C'est pas exactement ce à quoi je m'attendais, mais ca répond déjà en parti à la question, merci "guillemouze"

Raccourci pour implémenter une interface

EDI Delphi

Discussions similaires

Partager

Partager