Discussion :

[popo]

Bonjour,

J'utilise Delphi 7.
J'ai un comportement que je ne comprends pas dans l'utilisation et le passage d'un objet en paramètre.

J'ai une classe TMinimalTradeAddress défini comme suit :

Code :

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

1
2
3
4
5
TMinimalTradeAddress = class
private
public
  CountryId : String; // Code ISO pays (obligatoire)
end;

Je l’agrège à une classe TMinimalTradeParty

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
TMinimalTradeParty = class
private
  FTradeAddress : TMinimalTradeAddress;
public
  Name : String; // Nom (obligatoire)
 
  property TradeAddress : TMinimalTradeAddress read FTradeAddress; // Données de l'adresse
 
  constructor Create;
  destructor Destroy; override;
end;
 
constructor TMinimalTradeParty.Create;
begin
  FTradeAddress := TMinimaTradeAddress.Create;
end;
 
destructor TMinimalTradeParty.Destroy;
begin
  FreeAndNil(FTradeAddress);
  inherited;
end;

J'ai une classe TBasicTradeAddress héritant de TMinimalTradeAddress

Code :

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

1
2
3
4
5
6
7
8
9
10
TBasicTradeAddress = class(TMinimalTradeAddress)
private
public
  PostCode : String; // Code postal
  LineOne : String; // Adresse 1
  LineTwo : String; // Adresse 2
  LineThree : String; // Adresse 3
  CityName : String; // Ville
  CountrySubDivisionName : String; // Region
end;

Et une classe TBasicTradeParty héritant de TMinimalTradeParty et agrégeant un TBasicTradeAddress (héritant de TMinimalTradeAddress)

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
TBasicTradeParty = class(TMinimalTradeParty)
private
  FTradeAddress : TBasicTradeAddress;
public
  property TradeAddress : TBasicTradeAddress read FTradeAddress; // Données de l'adresse
 
  constructor Create;
  destructor Destroy; override;
end;
 
constructor TBasicHybridInvoiceTradeParty.Create;
begin
  inherited Create;
 
  FTradeAddress := TBasicTradeAddress.Create;
end;
 
destructor TBasicTradeParty.Destroy;
begin
  FreeAndNil(FTradeAddress);
  inherited;
end;

Mon problème se situe dans l'utilisation de ces classes et notamment dans les classes chargés de renseigner les données.

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
IMinimalDataCollector = interface
['{76C2E80F-CA36-48A6-87EF-DDDE2A7A44F6}']
  procedure FillTradeParty(TradeParty : TMinimalTradeParty); 
end;

IBasicHybridInvoiceDataCollector = interface(IMinimalDataCollector)
['{D4C43B05-58E5-40C4-87FA-4B0758C56633}']
  procedure FillTradePartyBasic(TradeParty : TBasicTradeParty);
end;

TMinimalDataCollector = class(TInterfacedObject, IMinimalDataCollector)
private
public
  procedure FillTradeParty(TradeParty : TMinimalTradeParty);
end;

TBasicDataCollector = class(TMinimalDataCollector, IBasicDataCollector)
private
public
  procedure FillTradePartyBasic(TradeParty : TBasicTradeParty);
end;

procedure TMinimalDataCollector.FillTradeParty(TradeParty: TMinimalTradeParty);
begin
  TradeParty.TradeAddress.CountryId := 'FR';
end;

procedure TBasicDataCollector.FillTradePartyBasic(TradeParty: TBasicTradeParty);
begin
  FillTradeParty(TradeParty); // <= Le problème se trouve ici

  TradeParty.TradeAddress.PostCode := '75018';
  TradeParty.TradeAddress.LineOne := '35 rue d''ici';
  TradeParty.TradeAddress.LineTwo := 'Line 2';
  TradeParty.TradeAddress.LineThree := 'Line 3';
  TradeParty.TradeAddress.CityName := 'PARIS';
end;

Lorsque j'arrive dans FillTradePartyBasic :
- TradeParty pointe sur une adresse mémoire A
- TradePartie.TradeAddress pointe sur une adresse mémoire B

Lorsque j'arrive dans FillTradeParty :
- TradeParty pointe toujours sur l'adresse mémoire A
- Mais TradePartie.TradeAddress pointe sur une adresse mémoire C (c'est le comportement que je ne comprends pas).

Et du coup CountryId n'est pas renseigné en sortant de FillTradeParty
Qu'est ce que j'ai fait de travers ?
Merci.

[Paul TOTH]

c'est normal, tu as bien deux instances distinctes TMinimalTradeParty.FTradeAddress et TBasicTradeParty.FTradeAddress

il y a plusieurs solutions, mais en tout état de cause, tu ne dois pas déclarer deux fois FTradeAdress, et surtout ne pas l'instancier deux fois

tu pourrais avoir quelque chose comme ça

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
 
constructor TMinimalTradeParty.Create;
begin
  CreateTradeAddress();
end;
 
procedure TMinimalTradeParty.CreateTradeAddress; // virtual
begin
  FTradeAddress   := TMinimalTradeAddress.Create;
end;
 
procedure TBasicTradeParty.CreateTradeAddress; // override
begin
  FTradeAddress   := TBasicTradeAddress.Create;
end;

ou si tu veux éviter d'écrire TBasicTradeAddress(FTradAddress) à chaque fois :

Code :

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

1
2
3
4
5
procedure TBasicTradeParty.CreateTradeAddress; // override
begin
  FBasicTradeAddress   := TBasicTradeAddress.Create;
  FTradeAddress := FBasicTradeAddress;
end;

[ALWEBER]

Essaye de mettre ton exemple dans un zip compilable car a priori il y a des anomalies dans ce que tu nous a envoyé.
Cordialement

[anapurna]

salut

il y a quelque lacune sur la POO

voici qulque notion a bien avoir en tete

encapsulation :
Private => l'accès aux données est réservé aux méthode(Procedure fonction) de sa propre classe.
Protected => l'accès aux données est réservé aux méthode(Procedure fonction) de sa propre classe et des classes héritières
Public => tout le monde peut y accéder

Heritage :

L'héritage facilite la réutilisation du code.
les objets d'une classe ont accès aux données et aux méthodes de la classe parent et peuvent les étendre

Attention : si tu redefini les méthodes ou les variable il s'agit alors de surcharge tu perd la notion d'heritage

polymorphisme :
Le polymorphisme permet de manipuler des objets sans en connaître tout à fait le type tout en se basant sur la relation d’héritage.

[popo]

c'est normal, tu as bien deux instances distinctes TMinimalTradeParty.FTradeAddress et TBasicTradeParty.FTradeAddress

il y a plusieurs solutions, mais en tout état de cause, tu ne dois pas déclarer deux fois FTradeAdress, et surtout ne pas l'instancier deux fois

Code :

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

1
2
3
4
5
procedure TBasicTradeParty.CreateTradeAddress; // override
begin
  FBasicTradeAddress   := TBasicTradeAddress.Create;
  FTradeAddress := FBasicTradeAddress;
end;

Y'a des fois où je mérite des baffes.
ça aurait dû me sauter au yeux...

Pour ceux qui aurait le même problème, je complète la réponse de Paul TOTH.
Il faut non seulement virtualiser et surcharger une méthode CreateTradeAddress mais également une méthode GetTradeAddress à placer en lecture des propriétés TradeAddress.
Cela implique de placer un reintroduce à la place du override pour changer le type dans la version Basique.

Code :

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

1
2
3
4
5
6
7
8
9
function TMinimalTradeParty.GetTradeAddress: TMinimalTradeAddress;
begin
  Result := FMinimalTradeAddress;
end;
 
function TBasicTradeParty.GetTradeAddress: TBasicTradeAddress;
begin
  Result := (FMinimalTradeAddress as TBasicTradeAddress);
end;

Essaye de mettre ton exemple dans un zip compilable car a priori il y a des anomalies dans ce que tu nous a envoyé.
Cordialement

J'ai volontairement raccourci les noms des classes.
A l'origine, ils sont beaucoup plus long mais du coup, j'ai réécrit vite fait, il est possible que j'ai fait quelques erreurs de copier-coller.

salut

il y a quelque lacune sur la POO

Heritage :

L'héritage facilite la réutilisation du code.
les objets d'une classe ont accès aux données et aux méthodes de la classe parent et peuvent les étendre

Attention : si tu redefini les méthodes ou les variable il s'agit alors de surcharge tu perd la notion d'heritage.

A mon avis, il y a surtout un gros manque de sommeil.
Mais il est toujours pas de rappeler les bases. Merci.