Discussion :

[rvzip64]

Salut,

Je sais qu'il est impossible d'accéder au private d'une classe qui se trouve dans une autre unité; donc dans mon code je met toutes les classes dans la même unité.

Sauf que maintenant je voudrais découper ce code et le placer dans des unités différentes. En c# il existe le mot clef internal.
Est ce qu'il existe une astuce ou un mot clef similaire en delphi pour réussir à faire la même chose ?

Merci d'avance pour vos réponses

[Montor]

• change la visibilité des champs concernés
• creer une class helper

[rvzip64]

lol merci je m'en doute un peu qu'il fallait changé de visibilité, mais je met quoi ??? actuellement c'est en private et je veux pas que cela soit en public...

Et pour le Helper ? tu vois ça comment ?

[Andnotor]

protected.

[rvzip64]

protected c'est pour les héritages...
Ce n'est pas mon cas

[Andnotor]

Alors défini mieux ton besoin .

Tu veux découper ton code... Quel code si ce ne sont pas des classes ?
Tu veux accéder à des propriétés private depuis une autre unité sans les passer en public Impossible !

ps: Protected n'est pas plus spécifique à l'héritage que les autres portées.

[rvzip64]

Pour info l'aide sur le protected

Un membre protégé est visible partout dans le module où la classe est déclarée et dans toute classe descendante, indépendamment du module où la classe descendante est définie. Une méthode protégée peut être appelée et un champ ou une propriété lu ou écrit, dans la définition de toute méthode appartenant à une classe qui dérive de celle où le membre protégé est déclaré. Généralement, les membres qui ne servent qu'à l'implémentation des classes dérivées sont protégés.

Il est donc (pout moi) plus spécifique à l'héritage qu'une autre visibilité.

Définir mieux mon besoin ? Je cherche l'"internal" du C# en Deplhi, ou un moyen de faire l'équivalent.

[Dr.Who]

Si la classe A doit pouvoir acceder au membres privée de la classe B,
il faut qu'elle soit dans la même unité.

une fois la dépendance créée de la sorte, elle ne sont plus extractibles l'une de l'autre.


autre moyen avec des Get sur pointeur protégé, exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
type
  TClassA = class
  private
    fA : integer;
  protected
    function GetAPtr : PInteger;
  public
    property A : integer read fA write fA;
  end;
 
function TClassA.GetAPtr: PInteger;
begin
  result := @fA;
end;

GetAPtr renvois tout simplement un pointeur sur l'adresse de la variable privée fA de l'instance en cours de TClassA.

cela evite de créer des Get/Set inutile et permet d'acceder directement
à la variable privée.
un peu brutal certe ... mais efficace.

pour ce qui est des classes helper, ce n'est pas leurs rôle et disponible uniquement a partir de D2007 et +.
Le rôle d'une classe helper et surtout l'ajout de fonctionnalités "on the fly" dans une classe sans besoin de la dérivé de nouveau.
méthode de tris, affichage alternatif, méthode redondante, ajout de méthode pour le support d'un nouveau format ou API etc.

par exemple, si on veux ajouter le support GDI+, OpenGL et DirectX aux composant de la VCL je peux ecrire des helpers plutot que de dériver les composants natif, exemple :

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
 
type
  TCanvasHelper = class helper for TCanvas
  public
    function ToGDIP: IGPGraphics;
    function ToGLIDE: IGlideContext;
    function ToDXDraw: IDirectDrawContext;
  end;
 
  TBitmapHelper = class helper for TBitmap
  public
    function ToGPCachedBitmap: IGPCachedBitmap;
    function ToGPBitmap: IGPBitmap;
    function ToGLMaterial: IGlideTexture;
    function ToDXDMaterial: IDirectDrawTexture;
    procedure ConvertFromPNG(PNG: TPNGImage);
    procedure ConvertFromJPG(JPG: TJPEGImage);
  end;

[Montor]

lol merci je m'en doute un peu qu'il fallait changé de visibilité, mais je met quoi ??? actuellement c'est en private et je veux pas que cela soit en public...

Et pour le Helper ? tu vois ça comment ?

mes proposition uniquement avec protected

Une instance d'un object est proche d'un Rocord
acceder a FCount

Code :

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

1
2
3
4
5
TTest =class
 private
 FCount :integer;
 FLimit   :integer;
....

Code :

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

1
2
3
4
5
6
7
var
 g:TTest;
 P:Pinteger;
begin
  g:=TTest.create;
  P:=pointer(Integer(g)+sizeof(Pointer));//le premier champs sur un instance est le pointeur vmt
  ShowmessageFmt('%d',[P^]);

voir aussi le class TFiler

Code :

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

1
2
3
4
5
TTestV =class
 protedted
 FCount :integer;
 FLimit   :integer;
....

Code :

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

1
2
3
4
var
 g:TTest;
begin
 TTestV (g).FCount ;

[ShaiLeTroll]

Bon, tu as un exemple ultra Violent dans la FAQ : "Comment accéder aux variables privées d'une classe ?"

Sinon, encore dans la FAQ, Comment accéder aux méthodes 'Protected' d'une classe ?, c'est moins violent, et très simple, cela triche justement avec le protected et la visibilité dans une unité ...

Avec la méthode de Dr Who, tu peux utiliser un Record ou un objet intermédiaire pour encapsuler toutes les propriétés partagées,

Enfin, une méthode un peu verbeuse, sans aucune tricherie dans ton code tu rends le second objet totalement dépendant du 1er, il me semble que l'on pourrait même faire quelque chose d'élégant avec les interfaces ... une Composition classique donc :

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
type
  TPrivateObject = class(...)
  private
    Data: TSharePrivateObject;
  public
    procedure ShareWith(Obj: TObject);
  end;
 
procedure TPrivateObject.ShareWith(Obj: TObject);
begin
  // Ici on pourrait ouvrir un peu plus avec une Interface, voir "Utilisation de l'opérateur as avec des interfaces"
  if Obj is TFriendObject then
  begin 
    TFriendObject(Obj).Associate(Data);
  end;

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
type
  TFriendObject = class(...)
  private
    ExternalData: TSharePrivateObject; 
  public
    constructor Create(Parent: TPrivateObject);
 
    procedure Associate(Data: TSharePrivateObject);
  end;
 
constructor TFriendObject.Create(Parent: TPrivateObject);
begin
  inherited Create();
 
  Parent.ShareWith(Self);
end;
 
procedure TFriendObject.Associate(Data: TSharePrivateObject);
begin
  ExternalData := Data; // Si Objet, c'est aussi simple que cela, sinon avec des Record, il faut passer par des Pointeurs ...
end;

A toi de voir si Parent est obligatoire, et de gérer dans ce Assigned avant chaque utilisation de ExternalData

[Montor]

Un champs private qui est accessible depuis une autre unité n'est pas vraiment privé
toutes les solutions oblige le passage par protected hiretage helper interface sauf si tu découpe la classe en plusieurs
"il faut penser hier"
si tu trouve maintenant ta classe est lourde et difficile pour la maintenance

[guillemouze]

Je vois pas trop l'intérêt de la chose.
Si tu veux accéder a des champs private depuis une autre classe, c'est que ton champ n'a rien a faire en private ! Si tu as rellement besoin qu'il soit private et d'y acceder, c'est que tes classes ont un lien tres fort entre elles, et dans ce cas la mieux vaut les laisser dans la meme unité, car la manipulation de champs private implique une connaissance sans faille de ce que tu fais.

[Paul TOTH]

il existe une chose propre que l'on peut faire malgré tout

1) déclarer les propriétés protected
2) déclarer une classe vide qui hérite de la classe qui nous intéresse.
3) transtyper avec cette classe

exemple:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
unit unit2;
interface
type
  TObject2 = class
  protected
    toto :string;
  end;
implementation
end.

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
 
unit unit1;
interface
uses
  unit2;
type
  TOpenObject2=class(TObject2)
  end;
implementation
var
 o : TObject2;
begin
  o := TObject2.Create;
 TOpenObjet2(o).toto := 'got it !';
end;
end.

[rvzip64]

guillemouze, ne le prend pas mal, mais je ne pense pas que ton commentaire soit constructif. Tu devrais relire mes posts , je dis bien que je cherche une méthode équivalente au internal du C# et que pour le moment mes variables sont en privés et c'est tout.


Autrement merci a tout le monde pour votre aide, je ne pensais pas qu'autant de monde aller proposer des solutions.

Je regarde tout vos conseils pour choisir au mieux la solution.

Merci encore.

[ShaiLeTroll]

il existe une chose propre que l'on peut faire malgré tout

Euh ça ne serait pas la même chose que la FAQ :Comment accéder aux méthodes 'Protected' d'une classe ?

[Kaféine]

Salut,

Je pense que il n'y a pas d'équivalent à "internal" du c# dans delphi vue qu'il n'y a pas de notion de namespace.

[Montor]

Si tu veux rester dans l'esprit C++ utilise la directive include,i
interface

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
unit MyHeaders;
interface
uses
  SysUtils,Classes;
type
  TCustomList=class;
 
  TMFiler=class
  private
    FMParams :TCustomList;
    FIndex :integer;
  public
    constructor Create(AList:TCustomList);
    procedure Read(var AItem);
    procedure Write(const AItem);
    property Idx : integer read FIndex write FIndex;
  end;
 
  TCustomList=class
  private
    FList  :TList;
    FAlloc :integer;
    FOnChange :TNotifyEvent;
    FUpdate   :boolean;
    FChanged  :boolean;
    FMFiler   :TMFiler;
    function Get(idx:integer):TMFiler;
    procedure Change();
  public
    constructor Create(AllocBy :integer);
    destructor Destroy();override;
    procedure Add(const AItem);
    procedure Delete(idx:integer);
    procedure Clear();
    function Count:Integer;
    procedure BeginUpdate();
    procedure EndUpdate();
    property Items[index:integer]:TMFiler read Get; default;
    property List : TList read FList;
    property Alloc : integer read FAlloc;
    property OnChange :TNotifyEvent read FOnChange write FOnChange;
  end;
 
implementation
{$i MyCpp}
 
// for Many parts 
//{$i MyCppPart_1}
//{$i MyCppPart_2}
//{$i MyCppPart_3}
end.

implementation
Fichier MyCpp.pas

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
{================================================================
                           TMFiler                              +
================================================================}
constructor TMFiler.Create(AList:TCustomList);
begin
    if Assigned(AList) then
    FMParams := AList;
end;
 
procedure TMFiler.Read(var AItem);
begin
  with FMParams do
  System.Move(Pointer(List[FIndex])^, AItem, Alloc);
end;
 
procedure TMFiler.Write(const AItem);
begin
  with FMParams do
  System.Move(AItem, Pointer(List[FIndex])^, Alloc);
end;
 
{================================================================
                           TMethodeParams                       +
================================================================}
constructor TCustomList.Create(AllocBy :integer);
begin
 
  if AllocBy in [1..255] then
    FAlloc  :=AllocBy
   else
    raise Exception.Create('');
  FMFiler  :=TMFiler.Create(Self);
  FList:=TList.Create;
end;
 
destructor TCustomList.Destroy();
begin
  Clear();
  FList.Free;
  inherited;
end;
 
procedure TCustomList.Change();
begin
 
    if not FUpdate then
    try
      if Assigned(FOnChange) then
         FOnChange(Self);
 
    finally
      FChanged  :=false;
    end
    else
       FChanged  :=true;
end;
 
procedure TCustomList.BeginUpdate();
begin
   FUpdate:=true;
end;
 
procedure TCustomList.EndUpdate();
begin
   FUpdate:=false;
   Change();
end;
 
procedure TCustomList.Delete(idx:integer);
begin
     dispose(FList[idx]);
     FList.Delete(idx);
     Change();
end;
 
procedure TCustomList.Add(const AItem);
var
  NewItem:Pointer;
begin
   GetMem(NewItem,FAlloc);
   System.Move(AItem, Pointer(NewItem)^, FAlloc);
   FList.Add(NewItem);
   Change();
end;
 
procedure TCustomList.Clear();
var
 i:integer;
begin
   for i:= 0to FList.Count-1 do
   try
     FreeMem(FList[i]);
   except
   end;
  if FList.Count <>0 then
  FList.Clear();
  Change();
end;
 
function TCustomList.Count:Integer;
begin
   result:=FList.Count;
end
;
function TCustomList.Get(idx:integer):TMFiler;
begin
   FMFiler.Idx:=idx;
   result:= FMFiler;
end;

[ShaiLeTroll]

L'idée de Montor est très pertinente, très utile pour les Tests Unitaires qui peuvent être mis dans un autre fichier, mais qui peuvent accéder aux méthodes privées ... cela permet d'affiner les tests au fonction plus petite puisque les méthodes publiques finalement ne sont souvent que des encapsulations et imbrications de méthodes privées ...

Attendons que rvzip64 nous communique la solution qu'il a retenue ...

[Montor]

la derrière chose a ajouter une compilation conditionnelle

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
  TCustomList=class
 {$IFDEF  CLASS_DUMP}
    public
 {$ELSE}
    private
 {$ENDIF}
    FList  :TList;
    FAlloc :integer;
    FOnChange :TNotifyEvent;
    FUpdate   :boolean;
    FChanged  :boolean;
    FMFiler   :TMFiler;
    function Get(idx:integer):TMFiler;
    procedure Change();
 {$IFNDEF  CLASS_DUMP}
  public
 {$ENDIF}
    constructor Create(AllocBy :integer);
    destructor Destroy();override;
    procedure Add(const AItem);
    procedure Delete(idx:integer);
...

[rvzip64]

J'aime bien aussi l'idée de Montor.

Je vais travailler la dessus en partant sur cette direction.

Merci à tous pour votre aide