ExposureRoom Home
  Log in Sign Up
Shiv's Website
Shiv Kumar
United States
Friends: 70
Focused on : 2
 
       
                                                             

Learn how to Build ASP Objects with Delphi
Not Rated YetNot Rated YetNot Rated YetNot Rated YetNot Rated Yet0votes
January 20, 2008 10:57 AM  Views:107   Favorited:0 Comments:0
Filed Under:  Programming
Tags:  ADO, ASP, COM, Database, Delphi
 
You will find a demo application of the project we are about to embark on at the link below.

Delphi Data Access ASP Object - A List Of Vendors

Here, The Data Access components are connected to the Vendors table in DBDEMOS Alias. In the Memo Field Provided you can type in a valid SQL Statement for that table to see the result in an HTML page. The ASP object is built such that is expects to see one parameters as a field in an HTML Form. This html page in turn calls on an ASP page that looks like this: 
<HTML>
<HEAD>
  <LINK REL=STYLESHEET TYPE="text/css" href="/home-styles.css">
  <TITLE> Delphi ASP Object Demo</TITLE>
</HEAD>
<BODY>
<CENTER><H2>Vendors Table from DBEMOS</H2></CENTER>
<HR>
<% Set DelphiASPObj = Server.CreateObject("DelphiASP.Vendor")
   DelphiASPObj.GetVendors
%>
<HR>
</BODY>
</HTML>


My project creates a file called DelphiASP.dll that is kept in the scripts folder. This library contains an object called Vendor that has a method called GetVendors. The parameter (SQL Statement) is "extracted" from the Request (ASP) object. The method GetVendors looks like this: 
procedure TVendor.GetVendors;
var
  sSQL : string;
begin
  sSQL := Request.Form['txtSQL'];
  Response.Write(DM.GetVendorInfoPage(sSQL));
end;

Building you first ASP object in Delphi

When people talk about ASP, they really mean ASP script, usually done using Visual Interdev, Drumbeat etc. ASP scripting is very different from ASP objects. ASP scripts are much slower as they are interpreted. ASP objects on the other hand are compiled (usually DLLs). IIS uses mechanisms that help speed up ASP scripts but these by no means make them as fast as compiled objects.

A big difference between ASP objects and ISAPI is that the ASP engine needs to be loaded in memory for ASP objects to run, while ISAPI DLLs are native DLLs (ASP DLLs are COM DLLs) and require fewer resource than ASP and have less layers to go through.

VB can build ASP objects too, but VB's threading capabilities are …..umm, lets just say….pitiful. What's a thread huh? Also, COM DLLs compiled with Delphi, like most things Delphi does are self contained. Yes they need the COM run time, but they don't need other DLLs, like VB DLLs or even VC COM DLLs for that matter.

Data Access speeds in Delphi once again are far better than VB. All in all, a COM DLL built in Delphi will out perform a COM DLL built in VB or VC .

How many ASP programmers do you think use ASP objects? Hardly any. Yes, they use third party objects by way of reusability. But they don't go around building their own ASP objects. They are primarily ASP scripting people.

As a Delphi programmer, you can build ASP objects that these programmers can use or you can build a whole web site using ASP objects. I'd personally, just use ISAPI, but then there are those that get caught up with buzzwords… If it weren't for buzzwords, I wouldn't be writing this article now would I?

The ASP engine that comes with Win98/Win2000 (needs to be installed for Win95.) is nothing but an ISAPI DLL. The name of the file is ASP.DLL. This DLL is loaded into memory by IIS, which in turn does the interpreting of ASP scripts or loads the ASP DLL objects into memory (along with a TON of other junk). For an ISAPI programmer (building ASP objects), this adds an unnecessary layer and slows things down due to the COM overhead. Believe you me, this overhead is a lot. Your server can do far better without this overhead.

So what's better, ASP or ISAPI? As per Microsoft (read my article - ISAPI versus CGI for quotes from the M$ web site), for speed, scalability and resources, use ISAPI, for all other things use ASP. I'd say, if you are a programmer, use ISAPI, if you're a VBer, use ASP<G>

Enough slandering, lets get on with our project.

In this project, we're going to build an ASP object that connects to the VENDORS table in DBDEMOS. A very simple project, but none the less, get the picture (ASP) across.

What is needed for this project

  1. I am personally using Firebird 1.0 for this project as well as my whole web site. You can download Interbase 6.0 for free from Here. I'm really impressed with its speed and light weight. I've upsized the DBDEMOS database to Interbase. Using the Interbase Express components that come with Delphi (Enterprise), I'm now free of the BDE as well. But you can use the standard DBDEMOS database (paradox) for this tutorial if you wish. The methods of the data access objects are the same. Some properties differ.
  2. You'll need to have the ASP engine installed if you are using Win95. You should probably be able to download this from the Microsoft site.
  3. Delphi Professional or Enterprise, since I believe these are the only versions that come with the ASP object (Wizard/Expert) option.
Before we really start building the project, lets see what exactly we're going to do. First we need to have an ActiveX library (COM DLL). To this library, we need to add an ASP object. We need to give this ASP objects a method, that will return the data from VENDORS table.

Getting ahead of ourselves a bit, lets examine the ASP file that will create our object and call its method. The ASP file looks like this: 
<HTML>
<HEAD>
  <TITLE> Delphi ASP Object Demo</TITLE>
</HEAD>
<BODY>
<CENTER><H2>Vendors Table from DBEMOS</H2></CENTER>
<HR>
<% Set DelphiASPObj = Server.CreateObject("DelphiASP.Vendor")
   DelphiASPObj.GetVendors
%>
<HR>
</BODY>
</HTML>
ASPArchitecture.png
Figure 1: Showing the Flow of a Request made by a web browser

As Shown in Figure 1 ASP works similar to ISAPI in that it receives a request, processes it, and sends back a response in the form of HTML. The <% and %> are the ASP script delimiters. The stuff between these delimiters is processed at the server end by the ASP engine. It will be replaced by HTML after processing. So imagine, if you will, that in the ASP file above, our method's output should result in HTML that will display data from the VENDORS table. The parts, before and after the ASP script delimiters are standard HTML.

In the ASP script

Looking at the ASP file above. More notably, the ASP script, you'll notice the VB syntax that creates a COM object. 
  Set DelphiASPObject = Server.CreateObject("DelphiASP.Vendor")
DelphiASP is the name of our ASP DLL file. In the DLL, we have an ASP object called Vendor. The next line: 
  DelphiASPObject.GetVendors
Once the object (DelphiASPObject, which is of the type DelphiASP) is created, we call its method - GetVendors. We create this method for our object and we have to implement this method. The result of this method returns a valid HTML string. And so, in this way, we've replaced the <% and %> with HTML that is then sent out through the (oh so sluggish) ASP/COM engine, then through the web server onto the (unsuspecting) client.

The Good news is that Delphi creates the .asp file for us.

Starting the Project

Lets get started with actually building the project.
  1. Form Delphi's File menu, choose New
  2. In the New Items Dialog, switch to the ActiveX Page.
  3. Choose ActiveX Library and then click OK.
  4. Form the File menu choose New
  5. In the New Items Dialog, switch to the ActiveX Page.
  6. This time Choose Active Server Object.
  7. In the New Active Server Object dialog, type is Vendor in the CoClass Name field.
  8. If you are using IIS 5.0 or later, Change the Active Server Type option to Object Context.
  9. Click OK
If you're not familiar with the various options presented in the New Active Server Object dialog, I suggest you read the on-line help on those various options by hitting the F1 key while the dialog is active.

You should now see the Type Library Editor as shown in Figure 2.

FirstASP1.png
Figure 2: Showing the Type Library Editor of the Active Server Object.

Lets save the project we've created thus far.
  • Save Vendor.asp as Vendor.asp
  • unit1.pas as uVendor_Impl.pas
  • Project1.dpr as DelphiASP.dpr
The unit, DelphiASP_TLB is the type library for our Active Server Object. Hitting the F12 key when this unit is active will toggle between the type library editor and this unit. The unit uVendor_Impl is the implementation of our Active Server Object. This is the unit in which we will write code to implement the methods we give our ASP object. Vendor.asp is the ASP file that, when called will create an instance of our ASP object and call the required method. 
<HTML>
<BODY>
<TITLE> Testing Delphi ASP </TITLE>
<CENTER>
<H3> You should see the results of your Delphi Active Server method below </H3>
</CENTER>
<HR>
<% Set DelphiASPObj = Server.CreateObject("Project1.Vendor") 
   DelphiASPObj.{Insert Method name here}
%>
<HR>
</BODY>
</HTML>
Notice, that the method name is unknown as this time and so we see{Insert Method name here} in its place. Once we create a method and implement it, it is our job to modify the .asp file such that is calls the right method of our object. Also notice the line 
<% Set DelphiASPObj = Server.CreateObject("Project1.Vendor")
Since this file was created before we saved our project with a new name, we need to change Project1 to DelphiASP. Lets go ahead and do that now.

The uVendor_impl.pas unit looks like this: 
unit uVendor_Impl;
interface
uses
  ComObj, ActiveX, AspTlb, DelphiASP_TLB, StdVcl;
type
  TVendor = class(TASPObject, IVendor)
  protected
    procedure OnEndPage; safecall;
    procedure OnStartPage(const AScriptingContext: IUnknown); safecall;
  end;
implementation
uses ComServ;
procedure TVendor.OnEndPage;
begin
  inherited OnEndPage;
end;
procedure TVendor.OnStartPage(const AScriptingContext: IUnknown);
begin
  inherited OnStartPage(AScriptingContext);
end;
initialization
  TAutoObjectFactory.Create(ComServer, TVendor, Class_Vendor,
    ciMultiInstance, tmApartment);
end.
Delphi has generated this unit for us. Notice that we have an object TVendor that is derived from TASPObject and implements the IVendor interface. So far, this is just a skeleton and it is this unit that we will write our implementation code in.

Some of you might have noticed that unlike an ISAPI/CGI project, we have no place to keep our components such as data access components. In other words, there is no web data module created for us. We could create all the components we want/need on the fly and use them that way. I prefer using a Data Module for this. So lets add new Data Module to our project.
  1. From the File menu, choose New
  2. Choose Data Module from the New Items dialog box.
  3. Name the Data Module - DM1
  4. Save the Project. When prompted, name the unit uDM

Creating the GetVendors Method

Since we're working with a COM object, we need to use the Type Library editor to give our object properties and methods. So lets get to the Type library Editor. If you don't see it, make the unit DelphiASP_TLB the active unit in the code editor and then hit the F12 key.

In the TreeView of the type library editor, you should notice our (COM DLL) library DelphiASP has an interface IVendor. Select IVendor in the TreeView and click on the New Method tool bar icon. When you see the new method, change the name to GetVendors.

Then click on the Refresh Implementation tool bar button in the type library editor. This action will create a skeleton of the implementation for us in the Delphi object that implements this interface. Namely, Tvendor in the unit uVendor_Impl.

Implementing the GetVendors Method

Most of this part is standard Delphi programming. One of the things that the base class for Delphi ASP objects (TASPObject) does is, it gives us access to the various ASP objects and methods, such as the Request and Response objects, the ASP Session object etc. So in any method within this unit, we have access to these objects.

In the implementation of the GetVendors method, we need to make sure, we generate valid HTML and hand it over to the Response object. The ASP Response object has a method called Write that declared as 
  procedure Write(varText: OleVariant); safecall;
Before we go any further, lets examine the difference between the ISAPI response object and the ASP response object. If we had code in an ISAPI application that looked like this: 
  Response.Content := 'Hello World';
In our ASP object it would be
  Response.Write('Hello World');
If on the other hand we had this in our ISAPI:
  Response.Content := 'Hello';
  Response.Content := Response.Content   'World';
In our ASP object it would be
  Response.Write('Hello');
  Response.Write('World');
You will notice that you won't find any documentation on the ASP objects in Delphi. They've left it to Microsoft to document. So you'll have to refer to the Microsoft web site for any documentation for the ASP objects. One place I've found such information is in MSDN

By way of good design, we're going to leave the Data Access methods to our DataModule. In our TVendor class, we'll call methods of the DataModule. This will keep our code cleaner. To use the Data Module from within our TVendor class, we need to add the Data Module's unit to the uses clause of the interface section (yes, the interface section and not the implementation section. We''l see why later). Once we've done that, we can call methods of our DataModule by referencing it.

We have only one line of code in the implementation of the GetVendors method of our TVendor class. 
Response.Write(DM1.GetVendorInfoPage);
GetVendorInfoPage is a public method of our DataModule.

The unit of our TVendor class should now look like this: 
<% Set DelphiASPObj = Server.CreateObject("Project1.Vendor")
Since this file was created before we saved our project with a new name, we need to change Project1 to DelphiASP. Lets go ahead and do that now.

The uVendor_impl.pas unit looks like this: 
unit uVendor_Impl;
interface
uses
  ComObj, ActiveX, AspTlb, DelphiASP_TLB, StdVcl, uDM;
type
  TVendor = class(TASPObject, IVendor)
  protected
    procedure OnEndPage; safecall;
    procedure OnStartPage(const AScriptingContext: IUnknown); safecall;
    procedure GetVendors; safecall;
  end;
implementation
uses ComServ;
procedure TVendor.OnEndPage;
begin
  inherited OnEndPage;
end;
procedure TVendor.OnStartPage(const AScriptingContext: IUnknown);
begin
  inherited OnStartPage(AScriptingContext);
end;
procedure TVendor.GetVendors;
begin
  Response.Write(DM.GetVendorInfoPage);
end;
initialization
  TAutoObjectFactory.Create(ComServer, TVendor, Class_Vendor,
    ciMultiInstance, tmApartment);
end.

Working on the DataModule

We've done nothing so far with the DataModule, so lets get started.
  1. Drop a TQuery on the DataModule
  2. Set its DatabaseName property to DBDEMOS
  3. Set its SQL property to SELECT * FROM VENDORS
  4. Set the Active property to True
  5. Drop a TSession component on the DataModule and set its AutoSessionName property to True
  6. Drop a TDataSetTableProducer component on the DataModule and set its DataSet property to Query1
  7. Declare a public method like so: 
    function GetVendorInfoPage(sSQL : string) : string;
  8. Complete the class (Ctrl SHIFT C) to create the implementation stub of this method


Figure 3 show what the Data Module should look like after having completed the steps outlined above.

FirstASP3.png
Figure 3 Showing the Data Module with its components

The unit for the DataModule should be like this: 
unit uDM;
interface
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs;
type
  TDM1 = class (TDataModule)
    Query1: TQuery;
    Session1: TSession;
    DataSetTableProducer1: TDataSetTableProducer;
  private
    { Private declarations }
  public
    function GetVendorInfoPage : string;
    { Public declarations }
  end;
var
  DM1: TDM1;
implementation
{$R *.DFM}
{ TDM1 }
function TDM1.GetVendorInfoPage: string;
begin
end;
end.
The function GetVendorInfo has only one line of code 
Result := DataSetTableProducer1.Content;
That's all there is to it! The output produced by this ASP object will be a simple HTML table as will be produced by the TDataSetTableProducer component. We can modify properties of this component to enhance the look of the HTML page produced. And we shall. But before we proceed …

One important thing you need to remember is that the DataModule is not going to be created automatically for us. We need to explicitly create and destroy the DataModule in our ActiveX Library projects. We'll create the DataModule in the OnStartPage method and Free it in the OnEndPage method of our TVendor class.

Also, notice the implementation of the GetVendors method of our TVendor class. We reference an object called DM and not DM1. DM has been declared as a read only property of our TVendor Class (hence the need to declare uDM in the interface section).

The uVendor_impl.pas unit now looks like this: 
unit uVendor_Impl;
interface
uses
  ComObj, ActiveX, AspTlb, DelphiASP_TLB, StdVcl, uDM;
type
  TVendor = class(TASPObject, IVendor)
  protected
    FDM : TDM1;
    procedure OnEndPage; safecall;
    procedure OnStartPage(const AScriptingContext: IUnknown); safecall;
    procedure GetVendors; safecall;
    property DM : TDM1 read FDM;
  end;
var
  DM : TDM1;
implementation
uses ComServ;
procedure TVendor.OnEndPage;
begin
  FDM.Free;
  FDM := nil;
  inherited OnEndPage;
end;
procedure TVendor.OnStartPage(const AScriptingContext: IUnknown);
begin
  inherited OnStartPage(AScriptingContext);
  FDM := TDM1.Create(nil);
end;
procedure TVendor.GetVendors;
begin
  Response.Write(DM.GetVendorInfoPage);
end;
initialization
  TAutoObjectFactory.Create(ComServer, TVendor, Class_Vendor,
    ciMultiInstance, tmApartment);
end.

Compiling and Testing

A couple of things are different from an ISAPI project here. The reason being, you're dealing with ASP and COM and not native DLLs.
  1. From the Project menu, choose Options and switch to the Directories/Conditionals page in the project options dialog.
  2. Set the Output Directory to your web servers scripts folder (C:\inetpub\scrits)
  3. Click the OK button
This will produce a DLL by the name DelphiASP in the scripts folder when we compile. We still can't use the DLL. All COM DLLs need to be registered with the system. We can use the Run|Register ActiveX Server menu option or from the Type Library editor we can click the Register Type Library tool bar button. When you do this, you should get a confirmation dialog stating that the registration was successful.

Now we're ready to use our ASP object. Remember that it is really the .asp file that will instantiate our ASP object and call its method. Lets make sure this ASP file is the way it should be. 
<HTML>
<BODY>
<TITLE> Testing Delphi ASP </TITLE>
<CENTER>
<H3> You should see the results of your Delphi Active Server method below </H3>
</CENTER>
<HR>
<% Set DelphiASPObj = Server.CreateObject("Project1.Vendor") 
   DelphiASPObj.GetVendors
%>
<HR>
</BODY>
</HTML>
Notice the line : DelphiASPObject.GetVendors. Your Vendor.asp file should have that line as it is shown above. Lets also move this file (after saving the project. Saving the project, also saves the .asp file) to our web server's root folder (C:\inetpub\wwwroot). We can now call this .asp file using the following URL in a web browser: 
  http://mydomain/vendor.asp
Where mydomain is the PC/Machine name of your PC or IP address (localhost or 127.0.0.1 will also do).

Figure 4 shows what the generated HTML page will look like if eveything goes well. Remember, if you need to re-compile this project after the ASP object has been created, you need to treat this DLL like an ISAPI DLL in that respect.

FirstASP4.png
Figure 4 showing the output of Vendor.asp

Enhancing the output

The TDataSetTableProducer component can be used similar to the way one would use it in an ISAPI application. We can use it here to format the HTML Table produced. You have access to the Response Editor as well as the various events this component has. Using the Response Editor we can:
  1. Set the HTML Table properties
  2. Decide which fields we want to show in the generated output
  3. Decide the order in which the fields are to be displayed
etc.

Using the Response Editor, lets set the Border attribute of the HTML Table to 1. Using the OnFormatCell event we can manipulate the HTML table even further. Here is what the OnFormatCell event of the TDataSetTableProducer should look like to produce an output similar to the demo you saw at the beginning of this article. 

procedure TDM1.DataSetTableProducer1FormatCell(Sender: TObject; CellRow,
  CellColumn: Integer; var BgColor: THTMLBgColor; var Align: THTMLAlign;
  var VAlign: THTMLVAlign; var CustomAttrs, CellData: String);
begin
  { Color the First Column }
  if CellColumn = 0 then
    BgColor := 'Teal';
  { Color the Second Column }
  if CellColumn = 1 then
    BgColor := 'Olive';
  { Color the Second Row - excluding the Field Name Row }
  if CellRow = 2 then
    BgColor := 'Red';
  { Color all instances of the Field - Preferred where the Value = False }
  if CellColumn = 10 then
  begin
    if CellData = 'F' then
      BgColor := 'Yellow';
  end;
end;

Modifiing the ASP Object to Read Form Data

What if we wanted our ASP object to respond to Data sent to it via an HTML Form? Lets modify our object, such that it receives the SQL string to use in the Query from an HTML Form as you might have seen in the Demo at the start of this tutorial.

So we're going to need:

  1. An HTML Page that allows us to define an SQL statement to be used by our ASP object, to generate an HTML output of the result set.
  2. This .htm file needs to call our ASP object and pass on to it the SQL statement
  3. Our ASP objects needs to be modified such that it looks for the SQL statement in the HTML Form's fields.
In an ISAPI application, we would "extract" an HTML Form's fields using code like this: 
  sSQL := Request.ContentFields.Values['txtSQL'];
Where sSQL is defined as a string type and txtSQL is the name of the field in the HTML Form that contains the requested SQL Statement to be applied to a Query object. Assuming here that the method of the HTML Form is POST and not GET.

In ASP, the Request object is a bit different. It has a property called Form. The way you would access the fields of a Form in ASP is: 

  sSQL := Request.Form['txtSQL'];
Once we get a hold of the SQL statement that was given to us via an HTML Form, we'd like to pass this on to our GetVendorInfo method of our Data Module, where we can assign the SQL string to our Query object and generate a result set.

Currently, our GetVendorInfoPage method does not expect any parameters, so we'll have to modify it such that it expects to see a string parameter and then use this parameter to assign it to our Query object and get a result set.

The GetVendors method of our ASP object will now look like this: 

procedure TVendor.GetVendors;
var
  sSQL : string;
begin
  sSQL := Request.Form['txtSQL'];
  Response.Write(DM.GetVendorInfoPage(sSQL));
end;
and the GetVendorInfoPage method of our DataModule will look like this: 
function TDM1.GetVendorInfoPage(sSQL : string) : string;
begin
  with Query1 do
  begin
    Close;
    SQL.Clear;
    SQL.Add(sSQL);
    Open;
  end;
  Result := DataSetTableProducer1.Content;
end;
Remember to change the declaration of this method in the interface section of the DataModule to match that shown above.

This concludes the changes we need to make to our ASP object such that it receives the SQL statement via an HTML form. We still need the HTML form however. The HTML form's source code looks like this: 

<HTML>
<HEAD>
  <TITLE>Delphi ASP Demo</TITLE>
</HEAD>
<BODY>
  <FORM ACTION="http://www.matlus.com/Vendor.asp" METHOD="POST">
   The <B>ASP Object</B> is connected to the VENDORS Table in DBDEMOS. Feel Free to Change the SQL Statement below to a Valid SQL Statement for this Table.
   <P>
 <TEXTAREA NAME="txtSQL" COLS=40 ROWS=5>SELECT * FROM VENDORS</TEXTAREA>
   <BR>
   <INPUT TYPE="SUBMIT"> 
  </FORM>
</BODY>
</HTML>
</PRE>
Notice the Form's ACTION attribute. It calls the Vendor.asp page, which in turn creates an instance of our ASP object, and calls its method. The Memo field's (TEXTAREA) name is important here, as it needs to match the name of the form field we're using in our ASP object sSQL := Request.Form['txtSQL'];. Save this .htm file as Vendor.htm.

To test our work, we need to load the Vendor.htm in our browser, set the SQL statement if required (you should test this) and clicking on the SUBMIT button on the Form. Figure 5 shows what the output will look like with an SQL statement of: SELECT VendorNo, VendorName, City, State, Zip, Preferred FROM VENDORS

FirstASP5.png
Figure 5 Showing the output generated by the ASP object

The flaw in our design here is that there is no column 10 and so even though the Preferred field is amongst the one we want displayed, it is not colored yellow where the value = False. We'll leave that as an exercise for those of you who would want to see this work.

Deploying the ASP Object

In most cases, you'd be developing your ASP objects on your development machine but later you'd want to deploy the ASP object on your production web server. What you need to do in this case is register your COM DLL on the production server. To do that you need to do the following:
  1. Place the COM DLL (DelphiASP.DLL in this case) in your web server's scripts folder (C:\inetpub\scripts).
  2. From the Start Menu, choose Run
  3. In the dialog box presented type -regsvr32 C:\inetpub\scrits\DelphiASP.DLL
  4. This action should register your COM DLL and give you a confirmation stating as such
  5. You will of course need an ASP file that instantiates your ASP object and calls its methods as well (similar to the Vendor.asp file)

ISAPI versus ASP

Unlike the ISAPI implementation in Delphi, which is event driven using Actions, ASP objects are method driven. In VB, you could use WebClasses to compliment your ASP scripts written using Visual InterDev and ASP objects in VB to achieve a somewhat event driven paradigm to web applications. This method adds one more layer to web applications written in VB that is known to slow things down even further.

The Delphi ISAPI/CGI framework, gives you all of that in a single place at break neck speeds and minimal resource utilization with incomparable scalability. So why bother with ASP.

A quote from the Microsoft site:
While no benchmarks are really going to give you the complete story, these benchmarks can tell you something. If WebClasses are slower, they aren't really that much slower (30%). Most of the performance loss is simply due to creating and destroying WebClass instances, which is not a sufficient reason to avoid using WebClasses. Moreover, if you're not willing to give up a little performance to get some extra productivity, you shouldn't be using Visual Basic or the ASP framework-you should be writing custom ISAPI extension DLLs with C .
In Delphi, ISAPI gives us the productivity we need. Productivity is comparable to what you would get if you were using Visual InterDev (minus the HTML Page design, but then you're not limited to using any tool for that purpose. Using HTML templates in a Delphi ISAPI frees you to use any HTML page designer to accomplish this end), with the benefits of ISAPI over any other competing technology for web based applications, without the headaches associated with ISAPI that a VC programmer relates to. In short, you got ISAPI the easy way. A way that no other development tool provides.

As a Delphi programmer do ASP only because you love to spout industry buzzwords. So why do I bother writing such an extensive Tutorial on Delphi and ASP ? First and foremost, it's nice to know that the Delphi R&D team has taken the trouble to give the Delphi programmer access to ASP objects as a technology. Secondly, It's good to know that Delphi does ASP. And thrid, for those of you who can't get around the buzzword (vicious) circle, you have the option to do ASP with Delphi.

Comments have been Disabled for this post

Menus

Theme
Privacy Policy  |  Terms Of Service  |  Contact Us  |  Support  |  Help/FAQs  |  News