Feststellen ob Anwendung die VCL verwendet

[igel457]

Hallo,

ich habe ein kleines Problemchen: Abhängig davon, ob eine Delphi Anwendung die VCL verwendet oder nicht, möchte ich entweder TThread.Synchronize verwenden oder eine eigene Non-VCL Methode. Um festzustellen, ob die VCL initialisiert ist oder nicht, müsste ich aber die Unit "Forms" einbinden, was bekanntermaßen die VCL automatisch initialisiert und die Größe der ausführbaren Datei aufbläht.

Momentan verwende ich folgenden Code, ich habe jedoch berechtigte Zweifel (TComponent wird erst mit der Registration von "TMenuItem" registriert), ob dieser Code mit allen Delphi-Versionen funktioniert:

Delphi-Quellcode:

function AcVCLActive: Boolean;
begin
  //The VCL can only be active, if the TComponent class is registered
  result := GetClass('TComponent') <> nil;
end;

Gibt es eine (zuverlässige) Möglichkeit festzustellen (entweder zur Compile- oder zur Laufzeit) ob die Anwendung die VCL (ich meine damit das vorhanden sein von TApplication) verwendet? Die Units "SysUtils" und "Classes" dürfen dabei verwendet werden.

Schonmal vielen Dank,
Andreas

[shmia]

Zur Laufzeit:

Delphi-Quellcode:

function IsVclApplication:Boolean;
begin
  Result := Assigned(Classes.FindGlobalComponent);
end;

[igel457]

Danke für die schnelle Antwort.

Leider scheinen neuere Delphi-Versionen mehrere "FindGlobalComponentProcs" zu unterstützen und die FindGlobalComponent-Funktion ist nun statisch in der Classes-Unit vorhanden:

Delphi-Quellcode:

function FindGlobalComponent(const Name: string): TComponent;
var
  I: Integer;
begin
  Result := nil;
  if FindGlobalComponentProcs <> nil then
  begin
    for I := FindGlobalComponentProcs.Count - 1 downto 0 do
    begin
      Result := TFindGlobalComponent(FindGlobalComponentProcs[I])(Name);
      if Result <> nil then Exit;
    end;
  end;
end;

Ich hatte auch schon vorher mit dieser Funktion herumgespielt, doch leider ist dabei nichts brauchbares entstanden...

Die "FindGlobalComponentProcs"-Liste ist leider nur privat für die Classes unit.

Edit: Kann ich vielleicht irgendwie über die RTTI an alle vorhanden Klassen kommen, die von TPersistent abgeleitet sind?

[H4ndy]

Vielleicht geht das ja.
Allerdings weiss ich nicht, ab wann dieses Compiler-Konstrukt funktioniert, hab nur D2010 zur Hand.

Delphi-Quellcode:

function AcVCLActive: Boolean;
begin
  {$IF Defined(TApplication)}
  Result := True;
  {$ELSE}
  Result := False;
  {$IFEND}
end;

[Helmi]

Zitat:

Zitat von H4ndy

Vielleicht geht das ja.
Allerdings weiss ich nicht, ab wann dieses Compiler-Konstrukt funktioniert, hab nur D2010 zur Hand.

Delphi-Quellcode:

function AcVCLActive: Boolean;
begin
  {$IF Defined(TApplication)}
  Result := True;
  {$ELSE}
  Result := False;
  {$IFEND}
end;

Nur so als Info:
Dieses Konstrukt wird unter D7 Pro kompiliert, aber es wird false rückgemeldet

[himitsu]

@H4ndy: Dieses prüft nur ob TApplication an der Codestelle verfügbar wäre.
Wobei ihm auch noch TApplication egal ist.

Mit Definied(TComponent) würde auch sowas geprüft
und am Ende ist dieses Ergebnis vollkommen irrelevant, da dieses nicht aussagt, ob diese Klasse auch verwendet wird,
abgesehn davon, daß man dafür auch noch die böse Forms-Unit einbinden muß, mit dem Ergebnis, daß man gleich TRUE zurückgeben kann. :roll:

[H4ndy]

@himitsu Ach stimmt, das sagt ja dann leider nix ueber die gesammte Anwendung aus :/
Forms muss man nicht dafuer einbinden, da das Defined() und Declared() eine reine Compiler-Anweisung ist.

Andere Frage: Kann man nicht einfach immer die NonVCL-Routine nutzen?

[himitsu]

Zitat:

Zitat von H4ndy

da das Defined() und Declared() eine reine Compiler-Anweisung ist.

Schon klar, wobei TApplication ihm doch vollkommen schnuppe ist,
aber um auf diese Weise z.B. TComponent prüfen zu können, muß man die entsprechende Unit einbinden.

@Lösung: Du könntest eventuell nachsehn, ob irgendwelche von der VCL verwendete/benötigte Resourcen vorhanden sind.

[igel457]

Vielen Dank schonmal für die ganzen Antworten.

Zitat:

Zitat von H4ndy

Andere Frage: Kann man nicht einfach immer die NonVCL-Routine nutzen?

Nein, leider geht das in meinem Fall nicht, da meine NonVCL-Routine nicht nur NonVCL, sondern auch noch Plattform unabhängig und auch für Konsolenanwendungen geeignet ist: Meine Notifications (wofür ich das ganze Brauche) werden hiervon einfach unsynchronisiert ausgegeben. Sobald die VCL/LCL vorhanden ist, möchte ich meine Notifications jedoch mit dem Hauptthread synchronisieren, da dies dem Anwender der Bibliothek ermöglicht ganz Transparent auf Events zu reagieren, ohne z.B. mit Mutices oder Critical Sections umgehen zu müssen.

In meiner alten Version des Codes, habe ich entsprechend einen Compilerswitch eingefügt, der explizit aktiviert werden muss, sobald man die VCL nicht verwendet. Da ich das Ganze nun neu geschrieben habe, möchte ich es so einfach verwendbar wie möglich haben. Und bevor jemand auf die Idee kommt das Vorzuschlagen: Die Synchronisation kann auch recht einfach vom Anwender selbst geschehen, er muss dann nur eine Funktion in einem Timer/Schleife/Was auch immer aufrufen.

Zitat:

Zitat von himitsu

Du könntest eventuell nachsehn, ob irgendwelche von der VCL verwendete/benötigte Resourcen vorhanden sind.

Das wäre nicht mal so dumm, schließlich könnte ich das sogar Plattformübergreifend mit einem TResourceStream machen...

Nochmal Danke, vielleicht hat jemand noch eine Zündende Idee,
Andreas

[himitsu]

Eine zündene Idee, wie der Anwender doch mithilft.
PS: Nur weil die VCL eingebunden ist, muß sie bei den Events dennoch keine Rolle spielen.

Bau doch einfach ein Feld/Property in deiner Komponente ein, wo man den SyncMode wählen kann.
(per Standard auf VCL-Synchronize ... sicher ist sicher, falls man das Setzen vergist)

[igel457]

Zitat:

Zitat von himitsu

Eine zündene Idee, wie der Anwender doch mithilft.
PS: Nur weil die VCL eingebunden ist, muß sie bei den Events dennoch keine Rolle spielen.

Bau doch einfach ein Feld/Property in deiner Komponente ein, wo man den SyncMode wählen kann.
(per Standard auf VCL-Synchronize ... sicher ist sicher, falls man das Setzen vergist)

Habe ich (mehr oder weniger)... Ist zwar keine Komponente, aber man kann einfach mittels folgender Funktionen...

Delphi-Quellcode:

{Allows you to set an own instance of a notification processor. This method has to be called before any other notification system procedure has been used.
@seealso(TAcNotifyProcessor)}
procedure AcNotifyManualSetProcessor(ANotifyProcessor: TAcNotifyProcessor);
{If you've initialized the notification queue system using the AcNotifyManualInit function, you must use this function to synchronize the notifications with the thread calling AcNotifyManualProcessQueue.
@seealso(AcNotifyManualInit)}
procedure AcNotifyManualProcessQueue;
{Initializes the notification system with TAcManualNotifyProcessor, allowing you to use the AcNotifyManualProcessQueue function.
@seealso(AcNotifyManualProcessQueue)}
procedure AcNotifyManualInit;

...beim Programmstart einen eigenen Prozessor für die Events festlegen oder auf den oben beschriebenen manuellen Modus umschalten. Macht man gar nichts wird bei der ersten Verwendung der Notify-Funktionalität der Standard ausgewählt. Entweder der TAcVCLNotifyProzessor oder eben der TAcNonVCLNotifyProcessor.

Ich möchte eben nur irgendwie automatisch den Standardprozessor setzen...

[Namenloser]

Also letztlich geht es ja um die Synchronize-Methode, oder? Wäre es da nicht u.U. einfacher zu prüfen, ob die "Maschinerie", die den internen Synchronize-Queue abarbeitet, existiert, als zu prüfen, ob die VCL eingebunden wurde? Ich habe da beim Überfliegen der Synchronisations-methoden in der Unit Classes den globalen Funktionszeiger "WakeMainThread" gefunden. Auf den ersten Blick scheint er ein ganz gutes Indiz zu sein:

Delphi-Quellcode:

if Assigned(WakeMainThread) then
   // VCL
else
  // NonVCL

Ich habe es nur kurz anhand einer neu erstellten VCL-Applikation bzw. einer leeren Konsolenapplikation getestet, dort lieferte der Test aber jedenfalls das korrekte Ergebnis.

[igel457]

Hallo,

dein Code funktioniert - auch mit Lazarus wird korrekt auf das vorhandensein der LCL (bzw. eines Handlers für Synchronize, was in der Tat das ist, was ich eigentlich möchte) hingewiesen. :thumb:

Vielen Dank,
Andreas