Discussion :

[tourlourou]

Bonjour,

Je m'interrogeais sur la meilleure manière de faire pour un objet singleton utilisant des procédures requérant des variables globales.

La structure actuelle est la suivante :

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
implementation
 
var
  UneSeuleInstance: TMyObject = nil;
  // ici les variables utiles à mes procédures, settées par mon objet
  procVar1, procVar2: integer;
 
procedure CallBack(aParam: integer);
begin
 //...
end;
 
procedure TMyObject.Create;
begin
  if Assigned(UneSeuleInstance)
  then raise Exception.Create('Une seule instance de TMyObject autorisée ; désolé.')
  else inherited Create;
  UneSeuleInstance:=self; // car singleton
  //...
end;

Serait-il plus "propre" de déclarer les procVar en :
1) class var en "compliquant" leur appel dans les CallBacks (TMyObject.procVar1) ?
2) membres privés de la classe, puisqu'une seule instance (UneSeuleInstance.procVar1) ?
3) autre ?

Merci pour vos avis !

[Paul TOTH]

bonjour,

le singleton est instancié (a priori), il n'y a donc pas lieu d'avoir des membres de classe

maintenant deux choses, soit tu fais de l'objet, soit tu n'en fais pas

version "moins" objet

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
 
unit MonUnit;
 
interface
 
type
  TMyObject = class
  end;
 
function GetInstance: TMyObject;
 
implementation
 
type
// on peut en profiter pour ajouter des choses invisibles
  TMyObject2 = class(TMyObject)
  end;
 
var
  Instance: TMyObject2 = nil;
 
function GetIsntance: TMyObject;
begin
  if Instance = nil then
   Instance := TMyObject2.Create;
  Result := Instance;
end;
 
end.

version "plus" objet

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
 
unit MonUnit;
 
interface
 
type
  TMyObject = class
    class var Instance: TMyObject;
    class function GetInstance: TMyObject;
  end;
 
implementation
 
function TMyObject.GetInstance: TMyObject;
begin
  if Instance = nil then
   Instance := TMyObject.Create;
  Result := Instance;
end;
 
end.

tu peux aussi surcharger le constructeur pour lever une exception

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
 
unit MonUnit;
 
interface
 
type
  TMyObject = class
   private
    class var Instance: TMyObject;
    constructor CreateInstance;
   public
    constructor Create; override;
    class function GetInstance: TMyObject;
  end;
 
implementation
 
constructor TMyObject.Create;
begin
   raise Exception.Create('Use TMyObject.GetInstance()');
end;
 
constructor TMyObject.CreateInstance;
begin
  inherited Create;
end;
 
function TMyObject.GetInstance: TMyObject;
begin
  if Instance = nil then
   Instance := TMyObject.CreateInstance;
  Result := Instance;
end;
 
end.

NB: outre les questions philosophiques, il n'y a pas de différence technique entre la version "moins" objet et la version "plus" objet

et dans les deux cas je considère qu'il faut retourner l'instance existante au lieu de lever une exception comme tu le fais.

[tourlourou]

Merci, Paul, pour tes exemples et avoir alimenté ma réflexion

[Papy214]

Paul, je trouve sympa ta troisième méthode sauf que ... pour le create, pas d'override

Ensuite, j'ai essayé (juste en changeant le nom, donc sans conséquence):

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
 
uses SysUtils;
 
type
 
  TSingleton = class
  private
    class var Instance: TSingleton;
    constructor CreateInstance;
  public
    constructor Create;
    class function GetInstance: TSingleton;
  end;
 
implementation
 
{ TSingleton }
 
constructor TSingleton.Create;
begin
  raise Exception.Create('Use TSingleton.GetInstance()');
end;
 
constructor TSingleton.CreateInstance;
begin
  inherited Create;
end;
 
class function TSingleton.GetInstance: TSingleton;
begin
  if Instance = nil then
    Instance := TSingleton.CreateInstance;
  Result := Instance;
end;

et dans une fiche appelante:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
uses UnitSingleton;
 
var
  Singleton: UnitSingleton.TSingleton;
 
procedure TForm2.Button1Click(Sender: TObject);
begin
  Singleton := UnitSingleton.TSingleton.GetInstance;
  Singleton.Free;
end;

Le premier clic passe sans problème.
Pour le second clic:
---------------------------
Opération de pointeur incorrecte.
---------------------------

ça devrait pourtant fonctionner non ??


le troisième clic me renvoie une violation d'accès.

Je suis sur un XE3

[Andnotor]

ça devrait pourtant fonctionner non ??

Que vaut Instance après Singleton.Free

[Papy214]

Je vais peut-être dire une connerie mais ... si ma variable Singleton représente la variable Instance, Instance est nil ...

Ou alors, y'a un truc qui m'échappe

J'ai remplacé le .Free par un FreeAndnil mais j'obtiens le même comportement

Un peu bouché le papy aujourd'hui ????