Cómo evitar ejecutar bloques en el IDE

[Eyewitness]

Hola a todos.

¿Alguien sabe cómo ejecutar una porción del código Delphi SOLAMENTE cuando se ejecuta el .exe desde fuera del IDE? Es decir, mantener activa esa parte del código para probar un ejecutable en el entorno del S.O, pero ignorarla cuando pulse "run" en el IDE de Delphi.

No tengo ni idea de compiler directives, así que no sé si hay alguna que haga esto.

Saludetes.

[Neftali [Germán.Estévez]]

En tu código utilizas esto:

Código Delphi [-]
 ...
{$IFDEF SOLO_IDE}    
  // lo que quieres que se ejecute sólo en el IDE
  _LogErrores(...)  
{$ENDIF}

En las opciones del proyecto en Directories/Conditionals hay una sección que dice "Conditional Defines".
Cuando esté trabajando normalmente en el IDE debe tener ese condicional:



Cuando vayas a generar la version definitiva lo eliminas antes de compilar.

Otra opción (más cómoda para mí) es utilizar un fichero .INC qe añades al proyecto.
En el fichero defines:

//********************** ATENCION ************************
//************  SE DEBE DESCOMENTAR PARA PRODUCCION ******
{.$DEFINE PRODUCCION}
//********************** ATENCION ************************

{$IFDEF PRODUCCION}     // ==>  ESTAMOS EN PRODUCCION
  //...  condicionales que queremos para producción
  {$DEFINE SOCKETS}
  ....
{$ELSE}
  //...  condicionales que no queremos para produccion (para el IDE)
  {$DEFINE SOLO_IDE}
   ...
{$ENDIF}

En este caso lo único que hay que hacer es:
(1) Cuando estás en el IDE, la linea en rojo debe ser (comentada, con punto):
{.$DEFINE PRODUCCION}
(2) Cuando no estás en el IDE, debe ser (sin punto):
{$DEFINE PRODUCCION}

Así sólo hay que poner o quitar punto al generar version definitiva.

[Eyewitness]

Gracias, Neftalí. Me das no solamente una opción, sino dos. Deluxe !!

A mí también me parece más interesante por comodidad usar un fichero .inc. Ya mismo me pongo a probar a implementarlo.

Buen finde !!!!

[roman]

Hola,

Aunque los condicionales del compilador son -en mi opinión- más que suficientes para aislar partes del código que queremos ejecutar sólo en determinadas ocasiones, tal como apunta Neftalí, me gustaría aclarar que esta técnica no discierne realmente si nuestra aplicación está o no ejecutandose desde el IDE, sólo distingue si al momento de compilar está o no definido un símbolo y hay que manipular éste y recompilar cada vez que deseemos cambiar el comportamiento.


Una manera de distinguir si el IDE está ejecutándose podría ser ésta:

Código Delphi [-]
function IsIDERunning(): Boolean;
begin
  Result := FindWindow('TAppBuilder', nil) <> 0;
end;

aunque resulta bastante ingenua pues sólo detecta si hay una ventana cuya clase se llame 'TAppBuilder' (que es como se llama la ventana principal del IDE de Delphi) pero el IDE podría estar abierto y aún así la aplicación ejecutarse desde fuera.


Una mejor aproximación es encontrando qué proceso lanza nuestra aplicación. Normalmente, si la ejecutamos desde fuera, este proceso será 'explorer.exe', mientras que si lo hacemos desde el IDE será 'delphi32.exe' (al menos para Delphi 7, que es con lo que estoy probando).

Dejo un par de funciones para esto último. La primera busca información de un proceso a partir de su identificador y la segunda deterrmina si la aplicacion la lanzó el IDE (1).

Código Delphi [-]
{
  Busca información de un proceso a partir de su identificador.

  La información se devuelve en el parámetro ProcInfo y la función
  devuelve true o false dependiendo de si se encontró  o no el
  proceso.

  Requiere la unidad TlHelp32
}
function FindProcess(ProcId: Cardinal; out ProcInfo: TProcessEntry32): Boolean;
var
  SnapShot: THandle;
  TempProcInfo: TProcessEntry32;

begin
  SnapShot := CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

  if SnapShot <> INVALID_HANDLE_VALUE then
    try
      ZeroMemory(@ProcInfo, SizeOf(ProcInfo));
      
      if Process32First(SnapShot, TempProcInfo) then
        repeat
          Result := TempProcInfo.th32ProcessID = ProcId;
          
          if Result then
            ProcInfo := TempProcInfo;
        until Result or not Process32Next(SnapShot, TempProcInfo)
      else
        Result := false;
    finally
      CloseHandle(SnapShot);
    end
  else
    raise Exception.Create('Cannot take snapshot of processes');
end;

{
  Determina si la aplicación se lanzó desde el IDE de delphi o no.
}
function RunningFromIDE(): Boolean;
var
  ProcInfo: TProcessEntry32;

begin
  Result :=
    FindProcess(GetCurrentProcessId(), ProcInfo) and
    FindProcess(ProcInfo.th32ParentProcessID, ProcInfo) and
    (ProcInfo.szExeFile = 'delphi32.exe');
end;

(1) Desde luego, estrictamente hablando, la función RunningFromIDE sólo determina si la aplicación fue lanzada por un proceso llamado 'delphi32.exe' y cualquiera puede hacer un proceso que así se llame y que no sea el IDE pero bueno, no estamos tratando de establecer un mecanismo de seguridad como los de tiempos antiguos en que los creadores de componentes shareware intentaban restringir su uso al IDE.

Regresando al punto original, podríamos usar esta función para ejecutar bloques condicionalmente dependiendo de si la aplicación corre desde el IDE o no:

Código Delphi [-]
if RunningFromIDE then
begin
  {
    Código que se ejecuta sólo desde el IDE
  }
end;

Aunque, como digo, la compilación condicional es más que suficiente para estos menesteres, creo que en ocasiones esta técnica puede ser cómoda pues nos evita estar cambiando los símbolos. Por ejemplo, ¿no se aburren de escribir una y otra vez el usuario y contraseña de su sistema cuando están haciendo pruebas? Podríamos poner

Código Delphi [-]
{$ifdef DEBUG}
txtUsuario.Tet := 'yomero';
txtPassord.Text := 'secreto';
{$endif}

de manera que cada vez que ejecutemos el sistema ya estén escritos nuestros datos. Pero ¿qué pasa si nos olvidamos de quitar el símbolo DEBUG antes de entregar la nueva versión?

Podríamos poner:

Código Delphi [-]
if RunningFromIDE then
begin
  txtUsuario.Tet := 'yomero';
  txtPassord.Text := 'secreto';
end;

y despreocuparnos de posibles olvidos.

// Saludos

[Eyewitness]

Muchas gracias, Román.

Ahora ya tengo trabajo para el fin de semana, porque cada método es ventajoso en unos aspectos frente a los otros dos...

Gracias a ambos, nuevamente, por vuestras soluciones.

[agustibaldo]

Estaba buscando una solución similar a la que daban para el caso de Eyewitness y tomé la idea de roman
Estoy utilizando Delphi 2010 y me encuentro con que no detecta el proceso. Hago la siguiente prueba:

Código Delphi [-]
   if RunningFromIDE() then
      ShowMessage('Debug!')
   else
      ShowMessage('Release!');

En la declaración de la función cambié: ProcInfo.szExeFile = 'delphi32.exe' por ProcInfo.szExeFile = 'bds.exe' y también por ProcInfo.szExeFile = 'bds.exe *32', pero cuando ejecuto la aplicación desde el IDE me aparece siempre el mensaje Release!
Tienen idea si hay que cambiar algo de la función para que trabaje correctamente?

Por otro lado les consulto: mi intención con esto es separar los ambientes de Desarrollo/Testing con Producción. Trabajo con SQL Server y realizo las conexiones a través de dbexpress donde los parámetros de conexión se encuentran en un dbxconnection.
La idea es detectar si el usuario corre la aplicación desde el IDE (modo Debug) o desde el acceso directo a la misma y a partir de eso conectar a las bases de datos de Desarrollo y Producción respectivamente. Es decir, cuando trabaje sobre el IDE solo use las bases de datos de desarrollo.

He investigado bastante pero no he encontrado una "forma estándar" de separar estos ambientes para evitar que los desarrolladores utilicen los datos de producción accidentalmente mientras realizan testing.

Espero que me puedan aconsejar sobre que modelo me conviene adoptar.
Desde ya, muchas gracias.

[[movorack]]

Hola,
Usa DebugHook para verificar si estás trabajando desde el IDE.

Código Delphi [-]
  if DebugHook = 1 then
  begin
    //Ejecutandose desde el IDE
  end;

[[movorack]]

Por otro lado con las directivas de compilación se puede asegurar que el ejecutable se comporte de una u otra manera en la fase de desarrollo.

Ej: Omitir login, otorgar permisos de superusuario, conectar a un servidor de bases de datos en especifico, etc...

Tal como lo explica neftalí :

Empezado por Neftali

En tu código utilizas esto:

Código Delphi [-]
 ...
{$IFDEF SOLO_IDE}    
  // lo que quieres que se ejecute sólo en el IDE
  _LogErrores(...)  
{$ENDIF}

En las opciones del proyecto en Directories/Conditionals hay una sección que dice "Conditional Defines".
Cuando esté trabajando normalmente en el IDE debe tener ese condicional:



Cuando vayas a generar la version definitiva lo eliminas antes de compilar.

Otra opción (más cómoda para mí) es utilizar un fichero .INC qe añades al proyecto.
En el fichero defines:

//********************** ATENCION ************************
//************  SE DEBE DESCOMENTAR PARA PRODUCCION ******
{.$DEFINE PRODUCCION}
//********************** ATENCION ************************

{$IFDEF PRODUCCION}     // ==>  ESTAMOS EN PRODUCCION
  //...  condicionales que queremos para producción
  {$DEFINE SOCKETS}
  ....
{$ELSE}
  //...  condicionales que no queremos para produccion (para el IDE)
  {$DEFINE SOLO_IDE}
   ...
{$ENDIF}

En este caso lo único que hay que hacer es:
(1) Cuando estás en el IDE, la linea en rojo debe ser (comentada, con punto):
{.$DEFINE PRODUCCION}
(2) Cuando no estás en el IDE, debe ser (sin punto):
{$DEFINE PRODUCCION}

Así sólo hay que poner o quitar punto al generar version definitiva.

[agustibaldo]

Excelente!! Funciona perfecto!
muchas gracias!!

[ozsWizzard]

Empezado por agustibaldo

[...]

Por otro lado les consulto: mi intención con esto es separar los ambientes de Desarrollo/Testing con Producción. Trabajo con SQL Server y realizo las conexiones a través de dbexpress donde los parámetros de conexión se encuentran en un dbxconnection.
La idea es detectar si el usuario corre la aplicación desde el IDE (modo Debug) o desde el acceso directo a la misma y a partir de eso conectar a las bases de datos de Desarrollo y Producción respectivamente. Es decir, cuando trabaje sobre el IDE solo use las bases de datos de desarrollo.

He investigado bastante pero no he encontrado una "forma estándar" de separar estos ambientes para evitar que los desarrolladores utilicen los datos de producción accidentalmente mientras realizan testing.

Espero que me puedan aconsejar sobre que modelo me conviene adoptar.
Desde ya, muchas gracias.

En mi caso, el host de la conexión con SQL Server se mantiene en un fichero INI, de esta forma, es independiente del ejecutable y se puede cambiar si alguna vez hay que debugar algo de producción.

Un saludo