[DUG]User defined routines...

[Sean Cross - CRM]

It depends how carried away you want to go.
 
You can simpy do it with carefull placement of units.  As the units are
only referenced by name, you could have eg UserRoutines.pas in every
project directory (not on the path) that impliments the project specific
stuff. 
  
Alternately, you can have a base object or interface defined that
includes the relevent routines.  That gets overriden for each project.
When the project starts it sets a global varaible (or uses a factory
method etc) with the correct instance.
 
Normally however, I would do something like that with events.  On
startup, sete the appropriate event handlers.  alternatly pass them in
as part of the method parameters.

Regards

Sean
-------------------------
Sean Cross
CRM
06 835 5868
021 270 3466 

 


________________________________

	From: delphi-bounces at ns3.123.co.nz
[mailto:delphi-bounces at ns3.123.co.nz] On Behalf Of John Bird
	Sent: Friday, 11 November 2005 11:18 a.m.
	To: 'NZ Borland Developers Group - Delphi List'
	Subject: [DUG]User defined routines...
	
	
	I use several shared/library routines called from different
places in programs.  Sometimes in one of these I want to call a further
routine which executes code that is relevant to the parent application
only.  What is the best way to do this in Delphi?
	 
	for example in other languages I could do:
	 
	example  -1
	Program1 calls Libraryroutine1
	Libraryroutine1 calls routine with a fixed name eg UserRoutine1
	 
	And I would have several separate source versions of
UserRoutine1, one for each application and the link file for the
application would specify whihch one got linked in, and hence called and
executed.
	 
	I can't do this in Delphi as the unit itself contains the
linking information in the uses clauses.
	 
	example - 2
	In other languages I have see code like
	 
	Callroutine(routinename,arg1,arg2,arg3.....)  where routinename
is a string variable that can be set to the value you want in
Application1, and the Callroutine would then call this routine
Routinename with the arguments arg1 arg2 etc  (ie the routine name
becomes a variable and can be pointed at different code.  Is this
possible or recommended in Delphi?
	 
	example - 3
	 
	This is one way you can do it in Delphi - you have a shared
routine UserRoutine1 containing all the code for all applications that
need it....
	 
	eg 
	 
	procedure UserRoutine1...
	 
	if  ExtractFileName(Application.exename)='Fred.exe' then
	begin
	    ....
	    ....
	end
	
	if  ExtractFileName(Application.exename)='Joe.exe' then
	begin
	    ....
	    ....
	end
	  
	if  ExtractFileName(Application.exename)='Bill.exe' then
	begin
	    ....
	    ....
	end
	 
	This works but is very clumsy in that code not relevant to the
application is compiled in, and also objects/forms/globals relevant to
one application are not useable as other applications will not be using
them.  In some cases where the UserRoutine is doing very limited local
stuff this may be fine, or limited numbers of these can be passed in as
parameters through LibraryRoutine1 to UserRoutine1.
	 
	What is the recommended or most elegant way to do this in
Delphi?  I am thinking maybe the easiest is using an include directive
to pick up the relevant library code for LibraryRoutine1 routine
directly into the application unit - which already contains code for
UserRoutine1
	 

	John

-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://ns3.123.co.nz/pipermail/delphi/attachments/20051111/381ad306/attachment.html