verschiedene Klassen via Compiler directive erzeugen

[bernhard_LA]

ich verwenden eine Interface und möchte jetzt über folgendes code Fragment :

Delphi-Quellcode:

{$IFDEF define(encrypt_full)}
  FLicense := Tlicense.create;
{$ELSEIF define(encrypt_tiny)}
  FLicense := TlicenseSimple.create;
{$ELSE}
  FLicense := TlicenseMock.create;
{$IFEND}

über die Einstellungen der Projektoptionen beim Compilieren die jeweilige Klasse erzeugen. Diese FLicense Klasse wird in mehreren Forms / units verwendet. Dort habe ich überall diesen Code eingebaut.


Problem : Egal was ich als Conditional define Parameter beim Compilieren auswähle, es wird immer nur die TlicenseMock Klasse erzeugt. Was mache ich falsch, wie erreiche ich mein Ziel ?

[himitsu]

Compile oder Build?

Der Compiler erzeugt von sich aus Units nur neu, wenn sie sich verändert haben und das tun sie hier nicht, also mußt DU explizit zwangsweise neu compilieren, also "alles neu erzeugen".
Ganz fies, wenn man solche DEFINES in den Projektoptionen umstellt, wo sich an den Code-Dateien dann garnichts ändert.

Aber sicher, dass dein Code so funktioniert?

$IFDEF prüft nur DEFINES, aber du willst CONDITIONAL-EXPRESSIONS auswerten und das macht man mit $IF.
Wenn der Parser echt doof ist und sowas durch lässt, dann könnten deine DEFINEs "define(encrypt_full)" und "define(encrypt_tiny)" heißen, anstatt "encrypt_full" und "encrypt_tiny".

Delphi-Quellcode:

{$IF define(encrypt_full)}
  FLicense := Tlicense.create;
...

Oder mmal so probieren.

Delphi-Quellcode:

// Unit 1 oder Include 1
const
  encrypt_full = False;
  encrypt_tiny = True;

// Unit 2
{$IF encrypt_full}
  FLicense := TLicense.Create;
{$ELSEIF encrypt_tiny}
  FLicense := TLicenseSimple.Create;
{$ELSE}
  FLicense := TLicenseMock.Create;
{$IFEND}

Beim Umstellen ändert sich Unit 1, wird neu kompiliert,
und mit etwas Glück erzwingt das auch ein Neukompilieren von Unit 2.

So muß es auf jeden Fall neu kompilieren und die Code-Optimierung müsste schlau genug sein und alle nichtbenötigten Zweige entfernen. (bei "echten" Konstanten)

Delphi-Quellcode:

// Unit 2
IF encrypt_full THEN
  FLicense := TLicense.Create
ELSE IF encrypt_tiny THEN
  FLicense := TLicenseSimple.Create
ELSE
  FLicense := TLicenseMock.Create;

Was durch typisierte Konstanten passiert, könnte noch interessant sein, da das in Wirklichkeit nur "schreibgeschützte" Variablen sind, deren eine Speicherstelle man dennoch verändern "könnte".

Delphi-Quellcode:

const
  encrypt_full: Boolean = False;
  encrypt_tiny: Boolean = True;

[Ghostwalker]

Das define in der if ist zuviel

Richtig wär:

Delphi-Quellcode:

// Unit 1 oder Include 1
//const
//  encrypt_full = False;
//  encrypt_tiny = True;

{.$DEFINE encrypt_full}
{$DEFINE encrypt_tiny}

// Unit 2
{$IFDEF encrypt_full}
  FLicense := TLicense.Create;
{$ELSEIF encrypt_tiny}
  FLicense := TLicenseSimple.Create;
{$ELSE}
  FLicense := TLicenseMock.Create;
{$IFEND}

http://docwiki.embarcadero.com/RADSt...ktive_(Delphi)

http://docwiki.embarcadero.com/RADSt...ktive_(Delphi)

Ein Zugriff auf "normale" Code-Konstanten innerhalb einer Compiler-Direktive ist logischerweise nicht möglich, das sie ja erst während des compilierens angelegt wird und so ggf. dem Compiler garnicht bekannt ist.

Alternativ zu den DEFINES in Unit1 kannst du das entsprechende Symbol auch über die Projektoptionen
(Delphi-Compiler->Bedingungen) definier. Dazu einfach das gewünschte Symbol mit einem ; anhängen
(BSP.: DEBUG;encrypt_tiny)

Hoffe mal das hilft dir weiter

[uligerhardt]

Zitat von Ghostwalker:

Ein Zugriff auf "normale" Code-Konstanten innerhalb einer Compiler-Direktive ist logischerweise nicht möglich, das sie ja erst während des compilierens angelegt wird und so ggf. dem Compiler garnicht bekannt ist.

Das stimmt so nicht. Folgendes funzt wunderbar:

Delphi-Quellcode:

program Project1;

{$APPTYPE CONSOLE}

uses
  SysUtils;

{$DEFINE TEST1}
const
  Test2 = 10;
begin
  try
{$IFDEF TEST1}
    Writeln('Test1');
{$ENDIF}
{$IF Declared(Test2)}
    Writeln('Test2 declared');
{$IFEND}
{$IF Test2>5}
    Writeln('Test2 biiiig');
{$IFEND}
    Readln;
  except
    on E: Exception do
      Writeln(E.Classname, ': ', E.Message);
  end;
end.

Im aktuellen Fall ist IFDEF natürlich trotzdem die bessere Wahl.

[bernhard_LA]

habe mir jetzt eine separate unit angelegt und definiere eine Interface-Alias-KlassenNamen- Klasse, damit ist dann nur eine Stelle + eine Zeile {$define .... } im Code anzupassen wenn ich die Klasse tauschen will und auch nur eine Zeile code in den Units die meine Interface Klasse verwenden

Delphi-Quellcode:

unit Unit_TlicenseAlias;

interface

uses  ...... ;


{$define  encrypt_tiny}

{$IFDEF encrypt_full}
 Type  TLicenseIClass  =class( Tlicense);
{$ifend}

{$IFDEF encrypt_tiny}
  Type  TLicenseIClass  =class( TlicenseSimple);
{$ifend}

{$IFDEF encrypt_Mock}
  Type  TLicenseIClass  = class(TlicenseMock);
{$IFEND}


implementation

end.

[uligerhardt]

Zitat von bernhard_LA:

habe mir jetzt eine separate unit angelegt und definiere eine Interface-Alias-KlassenNamen- Klasse, damit ist dann nur eine Stelle + eine Zeile {$define .... } im Code anzupassen wenn ich die Klasse tauschen will und auch nur eine Zeile code in den Units die meine Interface Klasse verwenden

Das "class" kannst du dir ggfs. noch sparen:
type TLicenseIClass = TLicense; geht auch.

[bepe]

Zitat von uligerhardt:

Das "class" kannst du dir ggfs. noch sparen:
type TLicenseIClass = TLicense; geht auch.

Im aktuellen Fall sicher ok, vermutlich sogar gewünscht. Generell sollte man, für Mitleser, aber erwähnen dass man ohne Class nur einen Alias definiert.

Delphi-Quellcode:

type TLicenseIClass = TLicense;  // ob man später TLicenseIClass oder TLicense verwendet macht keinerlei Unterschied (TLicenseIClass = TLicense: True)
type TLicenseIClass = class(TLicense);  // hier ist TLicenseIClass eine eigenständige Klasse, welche von TLicense erbt (TLicenseIClass = TLicense: False)