Gérer le mode "test" : variable de pré-compilation en Delphi

Version imprimable

Bonjour,

je voudrais disposer d'un équivalent de EnModeTest() de Windev autrement dit savoir si le projet a été lancé de l'éditeur (IDE) ou de manière autonome. Je pourrais éventuellement utiliser le mode Debug en test et le mode Release pour la construction de l'exécutable autonome... Mais une erreur (humaine) est si vite arrivée !:aie:

Bref, à mon avis, je jouerais cela avec une variable de compilation... si c'est jouable en Delphi. Je ne sais pas.

Quel est l'intérêt ? Pour atteindre mes bases de test j'utilise mon IP interne (mon réseau local). Évidemment, un utilisateur utilisera l'IP publique (l'adresse fournie par mon Provider). Je pourrais éventuellement créer un ini mais je suis un adepte du all-in-one. Je pourrais également utiliser un Nat Hairpinning (chez moi un "Livebox Orange Nat Loopback":aie:) mais ma LiveBox semble ne pas le supporter. je pourrais aussi utiliser un code genre :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 With UniConnection1 do begin if Connected then Connected := False; Server := 'mon IP publique'; //L'adresse publique du serveur try Connected := true; except Server := '192.168.0.200'; //L'adresse locale du serveur end; if not Connected then try Connected := true; except sMess := 'Serveur indisposnible.'; end; [...]
Mais c'est lent.

Bref, en C++, j'utilise une variable de pré-compilation. Une approche Delphi ?

MErci. Cordialement. Gilles
e

Bonjour,

pour savoir si l'exécution se fait depuis l'IDE ou en dehors, j'utilise ceci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
  If DelphiLoaded then
     Begin
//  Lancement depuyis l'IDE
     End
  Else
     Begin
// Lancement depuis l'exe
     End ;
 
 { =========================================================================== }
function DelphiLoaded: Boolean;
begin
  DelphiLoaded := False;
  if (FindWindow('TPropertyInspector', nil) > 0) then
      if (FindWindow('TAppBuilder', nil) > 0) then
        if (FindWindow('TApplication', nil) > 0) then
          if (FindWindow('TAlignPalette', nil) > 0) then
            DelphiLoaded := True;
end;
 { =========================================================================== }

je pense que cela fonctionne depuis D7 jusqu'à D10.3 (à vérifier )

Cela me permet de gérer des répertoires de travail différents en exe normal et en cours de dev

A+
Charly

:recherch:

Tester si l'application est exécutée depuis l'EDI

Citation:

Envoyé par ShaiLeTroll

VariableGlobale System.DebugHook pour un débug via Delphi

Sinon pour un mode debug général, tu as la fonction Windows.IsDebuggerPresent

Code:

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
//------------------------------------------------------------------------------
// Voir IsDebuggerPresent (API Windows SDK)                                    -
//                                                                             -
// L'aide API SDK Windows semble indiquer que cette function IsDebuggerPresent -
// n'est disponible qu'avec NT, à vérifier sur Win9x                           -
//                                                                             -
// IsRunInDebugger remplace la déclaration simple de Library sous Delphi       -
//                                                                             -
// interface                                                                   -
//    function IsDebuggerPresent(): BOOL; stdcall;                             -
//    {$EXTERNALSYM IsDebuggerPresent}                                         -
//                                                                             -
// implementation                                                              -
//    function IsDebuggerPresent; external kernel32 name 'IsDebuggerPresent';  -
//                                                                             -
//----------------------------------------------------------------------------*)
 
var
   _FKernelDLL: THandle = 0;
   _FVersionWindows: DWord = 0;
   _FFlagDebug: Boolean = False;
   _FFlagDebugChecked: Boolean = False;
   _IsDebuggerPresent: function: BOOL; stdcall;
 
function IsRunInDebugger(): Boolean;
var
   OSInfo: OSVERSIONINFO;
begin
   Result := _FFlagDebug;
 
   // Est-ce que le Flag a été Lu, si oui on Sort
   if _FFlagDebugChecked then
      Exit;
 
   // To know if a Application is running under de Delphi IDE or when it's running stand-alone
   if System.DebugHook <> 0 then
   begin
      _FFlagDebug := True;
      _FFlagDebugChecked := True;
   end;
 
   // Récupération de la Version de Windows
   if _FVersionWindows = 0 then
   begin
      OSInfo.dwOSVersionInfoSize := SizeOf(OSVERSIONINFO);
      if GetVersionEx(OSInfo) then
      begin
         _FVersionWindows := OSInfo.dwPlatformId;
      end;
   end;
 
   // Si la Versin de Window est inférieur à NT ou 9x, le Résultat est Faux
   if _FVersionWindows >= VER_PLATFORM_WIN32_WINDOWS then
   begin
      // Chargement de la DLL et de la Procedure
      if @_IsDebuggerPresent = nil then
      begin
         if _FKernelDLL = 0 then
         begin
            _FKernelDLL := LoadLibrary(PChar(Kernel32));
         end;
 
         if _FKernelDLL > 0 then
         begin
            @_IsDebuggerPresent := GetProcAddress(_FKernelDLL, 'IsDebuggerPresent');
         end;
      end;
 
      // Utilisation de la Procédure Chargée
      if Assigned(@_IsDebuggerPresent) then
      begin
        _FFlagDebug := _IsDebuggerPresent();
      end else
      begin
         _FFlagDebug := False;
      end;
      // Peu Importe si la Procédure Existe, on considère que l'on a testé la valeur
      _FFlagDebugChecked := True;
 
   end else
   begin
      // Windows antérieur à WinNT, Détection du Mode Débogage impossible !
      _FFlagDebug := False;
      _FFlagDebugChecked := True;
   end;
 
   Result := _FFlagDebug;
end;
 
initialization
  _FKernelDLL := 0;
 
finalization
  if _FKernelDLL > 0 then
     FreeLibrary(_FKernelDLL);
 
end.

10/12/2018, 11h48
Invité

2 pièce(s) jointe(s)
Rebonjour,

Merci.... mais le problème est que ce n'est pas portable.

Je crois avoir trouvé une solution simple. En Delphi cela s'appelle "Directive" de compilation et pas "variable de pré-compilation". Voila pourquoi je ne trouvais pas sur le net.

1. Je crée une sous-configuration dans release :

Pièce jointe 433316

2. Et j'ajoute dans cette configuration une directive :
Pièce jointe 433324

3. Dans le programme :
Code:

1 2 3 {$IFDEF DEPLOY} showmessage('Deploiement'); {$ENDIF}
Encore merci pour votre aide. Cordialement. Gilles