Announcement

**Hagen Reddmann** · 09.10.2002, 18:02

<pre>

var
Class: TPersistentClass;
Persistent: TPersistent;
begin
RegisterClass(TBitmap);
Class := GetClass('TBitmap');
if Class <> nil then
Persistent := Class.Create;
end;

</pre&gt

**Helmut Schumacher** · 10.10.2002, 09:41

<pre>
Hallo Hagen,
zu nächst mal vielen Dank für die schnelle Reaktion.
In meiner Anwendung sind unterschiedliche Threads zu starten.
Jeder Thread ist eine Klasse vom Typ Thread dieser ist leider von
TObject abgeleitet. Über ein Interface übergebe ich den Namen des zu startenden Thread als String. Alle Threads haben einen geänderten Constructor, welchem Parameter übergeben werden.

Gibt es dafür auch eine Lösung?

Helmut
</pre&gt

**Hagen Reddmann** · 10.10.2002, 10:27

Nein, nicht in ObjectPascal. Das was Du willst geht sogar in Interpretierenden Sprachen sehr schlecht.
Man könnte die Constructoren vereinheitlichen, alle Thread müssen von
ein und der selben KLassen abgeleitet sein, und in dieser Klasse werden die Interfaces zur individuellen Initialisierung vorgegeben.
Dann müsste jeder abgeleitete Thread diese Interfacebeschreibungen überschreiben, und deine allgemeine Thread-Erzeugung Funktion die Informationen benutzen um eine korrekte Parameterübergabe zu bekommen. 

Allerdings wäre das dann am Sinn von OOP weit vorbei. Am besten ist es mal wenn du beschreibst in welchem Szenario du dies benötigst. Vielleicht lässt sich das Problem ganz anders lösen.

Gruß Hage

**Helmut Schumacher** · 10.10.2002, 12:54

<pre>
Hallo Hagen,
zur Anwendung:
Eine Client / Server-Anwendung
Im Server gibt es etwar 20 Klassen, die von Thread abgeleitet sind.
Darüber haben alle Klassen eine gemeinsame Klasse in der der Construktor angelegt ist. Also der Aufruf ist immer der selbe.
Darüber liegt dann die Klasse, in der die spezifischen funktionen liegen. Diese haben alle andere Namen und mit dem Name wird die Klasse dann aufgerufen. Dieser Name wird vom Client dem Server übergeben.
Nun wird dort der String abgefragt und mit if-Bedingungen die zu startende Klasse aufgerufen.
Ich versuche mal zu beschreiben
TObjekt-TThread-ClassMitCreate-Txyz;
TObjekt-TThread-ClassMitCreate-Tzyx;
... usw.

procedure(Modul: String; P1, P2, P3: Integer);
begin
if Modul = 'xyz' then
xyz := Txyz.create(P1,P2,P3);
.
.
.
if Modul = 'zyx' then
zyx := Tzyx.create(P1,P2,P3);
end;
In der Anwendung sieht das natürlich wesendlich unübersichtlicher aus.
Ich dachte mir, man könne einen Variant benutzen, und dem an Hand des
Namen den Typ übergeben und diesen Starten.

Helmu

**Hagen Reddmann** · 10.10.2002, 13:05

Naja, falls alle diese Thread Object den gleichen constructor habe geht das doch:

<pre>

type
TBaseThreadClass = class of TBaseThread;
TBaseThread = class(TThread)
public
constructor Create(P1,P2,P3: Integer); virtual;
end; 

TBaseThread_XYZ = class(TBaseThread)
publich
constructor Create(P1,P2,P3: Integer); override;
end; 

procedure RegisterBasethread(Class: TBaseThreadClass);
begin
RegisterClass(Class);
end; 

function CreateBaseThreadByName(const Name: String; P1,P2,P3: Integer): TBaseThread;
var
Class: TClass;
begin
Class := GetClass(Name);
if (Class = nil) or not Class.InheritsFrom(TBaseThread) then
raise Exception.Create('Class not found');
Result := TBaseThreadClass(Class).Create(P1, P2, P3);
end; 

</pre>

Gruß Hage

**Helmut Schumacher** · 10.10.2002, 19:48

<pre>
Hallo,

ich habe das leider nicht richtig verstanden.
Aber ich habe folgendes ausprobiert:
Die Unit, in der ich dem Thread das endgültige "Aussehen" gebe,
erweitere ich um

initialization
RegisterClass(TPersistentClass(TSt7Auslesen));
dann erweitere ich die besagte Aufruffunktion (andere Unit) wie folgt:
</pre>
TempClass := getClass('TSt7Auslesen'); 
if (TempClass <> nil) and TempClass.InheritsFrom(TCustomDWConnectAsBDE) then 
TempThead := TCustomDWConnectAsBDE(TempClass).Create(1,2,3); 
leider gibt es beim Registrieren eine Exeption, also gleich beim Aufrufen der Anwendung. 
Ich glaube es liegt daran, weil TThread von TObject abgeleitet ist, und nicht von TPersistent? 
Wenn aber das Registrieren so klappen würde, dann hätten wir erheblich weniger Entwicklungsaufwand, da der Unit mit dem Aufruf nicht alle Units der Threads bekannt sein müssen. Und diese auch sonst nicht ständig verändert werden müsste, wenn ein neuer Thread dazu kommt.

Helmut
&#10

**Hagen Reddmann** · 11.10.2002, 10:06

Dann schreib deine eigene Registrations Routinen, ist vielleicht eh besser so:

<pre>

procedure RegisterThread(const Class: TBaseThreadClass);
function CreateThread(const Name: String; P1,P2,P3: Integer): TBaseThread; 

implementation 

var
ThreadClasses: TStringList = nil; 

procedure RegisterThread(const Class: TBaseThreadClasss);
begin
if ThreadClasses = nil then ThreadClasses := TStringList.Create;
ThreadClasses.AddObject(Class.ClassName, Pointer(Class));
end; 

function GetThreadClass(const Name: String): TBaseThreadClass;
var
I: Integer;
begin
if ThreadClasses = nil then raise Execption.Create('Class not found');
I := ThreadClasses.IndexOf(Name);
if I < 0 then raise Exception.Create('Class not found');
Result := Pointer(ThreadClasses.Objects[I]);
end; 

function CreateThread(const Name: String; P1, P2, P3: Integer): TBaseThread;
begin
Result := GetThreadClass(Name).Create(P1, P2, P3);
end; 

finalization
FreeAndNil(ThreadClasses);
end. 

</pre>

Gruß Hage

**Helmut Schumacher** · 12.10.2002, 10:25

<pre>
Hallo Hagen,
die Ide ist sehr gut. Nur leider komme ich noch nicht weiter.
Folgende habe ich versucht:
In jeder Threadunit habe ich ein Abschnitt
initialization
RegisterThread('TSt7Auslesen', TSt7Auslesen);
eingefügt.
In einer neuen Unit habe ich die benötigten Funktionen aufgenommen
procedure RegisterThread(const Name: String; const TClass: Pointer);
begin
ThreadClasses.AddObject(Name, TClass);
end;

function GetThreadClass(const Name: String): Pointer;
var
I: Integer;
begin
if ThreadClasses = nil then
raise Exception.Create('Class not found');
I := ThreadClasses.IndexOf(Name);
if I < 0 then
raise Exception.Create('Class not found');
Result := Pointer(ThreadClasses.Objects[I]);
end;
Nun der Aufruf
procedure startThread(ThreadName: String);
var ThreadClass: TCustomDWConnectAsBDE;
TempThread: Pointer;
begin
ThreadClass := GetThreadClass(ThreadName);
TempThread := ThreadClass.Create(1,2,3);
end;
leider tritt im Construktor ein Fehler auf bei:
inherited Create(true);
dies ist wohl der Aufruf von TThread?
Was kann falsch sein??

Helmut</pre&gt

**Hagen Reddmann** · 12.10.2002, 12:39

Deine Verwendung von Pointer muß falsch sein. Ganz wichtig

<pre>

function StartThread(const ClassName: String, P1, P2, P3: Integer): TBaseThread;
begin
Result := GetBaseThreadClass(ClassName).Create(P1, P2, P3));
end; 

// das impliziert 

function StartThread(const ClassName: String; P1, P2, P3: Integer): TBaseThread;
var
BaseThreadClass: TBaseThreadClass; // <- NICHT Pointer o.a.
begin
BaseThreadClass := GetBaseThreadClass(ClassName);
Result := BaseThreadClass.Create(P1, P2, P3);
end; 

// dafür MUSS aber 

type
TBaseThreadClass = class of TBaseThread;
TBaseThread = class(TThread)
public
constructor Create(P1, P2, P3: Integer); virtual; 
end; 

// sein, und demnach 

type
TMyWorkingThread = class(TBaseThread)
public
constructor Create(P1, P2, P2: Integer); override; 
end; 

// clever wäre auch 

type
TBaseThread = class(TThread)
public
constructor Create(....); virtual;
class procedure Register;
end; 

class procedure TBaseThread.Register;
begin
RegisterBaseThreadClass(Self);
end; 

initialization
TWorkingThreadClass.Register;
end. 

</pre>

Gruß Hage

**Hagen Reddmann** · 12.10.2002, 12:52

<pre>

<code>unit BaseThread;
 
interface
 
uses Classes;
 
type
TBaseThreadClass = class of TBaseThread;
 
TBaseThread = class(TThread)
public
constructor Create(P1, P2, P3: Integer); virtual;
class procedure Register;
end;
 
function StartBaseThread(const ClassName: String; P1, P2, P3: Integer): TBaseThread;
 
implementation
 
uses SysUtils;
 
var
FBaseThreadClasses: TStringList = nil;
 
constructor TBaseThread.Create(P1, P2, P3: Integer);
begin
inherited Create(True);
end;
 
class procedure TBaseThread.Register;
resourcestring
sAlreadyRegistered = '%s ist schon registriert';
begin
if FBaseThreadClasses = nil then FBaseThreadClasses := TStringList.Create;
if FBaseThreadClasses.IndexOf(ClassName) >= 0 then
raise Exception.CreateFmt(sAlreadyredistered, [ClassName]);
FBaseThreadClasses.AddObject(ClassName, Pointer(Self));
end;
 
function StartBaseThread(const ClassName: String; P1, P2, P3: Integer): TBaseThreadClass;
 
procedure Error;
resourcestring
sNotRegistered = '%s ist nicht registriert';
begin
raise Exception.CreateFmt(sNotRegistered, [ClassName]);
end;
 
var
I: Integer;
BaseThreadClass: TBaseThreadClass;
begin
if FBaseThreadClasses = nil then Error;
I := FBaseThreadClasses.IndexOf(ClassName);
if I < 0 then Error;
BaseThreadClass := Pointer(FBaseThreadClasses.Objects[I]);
if BaseThreadClass = nil then Error;
if not BaseThreadClass.InheritsFrom(TBaseThread) then Error;
Result := BaseThreadClass.Create(P1, P2, P3);
end;
 
initialization
finalization
FreeAndNil(FBaseThreadClasses);
end.

</code></pre&gt

**Hagen Reddmann** · 12.10.2002, 12:52

<pre>

<code>// nun die Anwendung von obigem
 
unit Unit1;
 
interface
 
uses BaseThread;
 
type
TWorkingThread = class(TBaseThread)
public
constructor Create(P1, P2, P3: Integer); override;
end;
 
implementation
 
constructor TWorkingThread.Create(P1, P2, P3: Integer);
begin
inherited Create(P1, P2, P3);
end;
 
initialization
TWorkingThread.Register;
end.

</code></pre&gt

**Hagen Reddmann** · 12.10.2002, 12:56

<pre>

<code>// und der Test
 
procedure TestThread;
var
Thread: TBaseThread;
begin
Thread := StartBaseThread('TWorkingThread', 1, 2, 3);
Assert( Thread <> nil );
Assett( Thread.InheritsFrom(TBaseThread) );
end;

</code></pre&gt

**Helmut Schumacher** · 14.10.2002, 10:01

SUUUPER, 
so gehts 
Helmu

Announcement

Name eines Objects als Parameter übergeben

Name eines Objects als Parameter übergeben

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment

Comment