Cross Ref > Language Details

ASP Classic is a non-OOP language with some OOP features. It offers both Subs and Functions. A Sub does not return a value while a Function does. When Subs and Functions are used in a defined class, they become the methods of the class.

Sub SayHello(ByVal pName)
  Response.Write "Hello " + pName + "!<br>"
End Sub
 
Function Add(ByRef pN1, ByRef pN2)
  Add = pN1 + pN2
End Function

 ASP Classic Custom Routines (Sub, Function)

In Prism, everything is within a class (just like with C#, VB.Net, and Java). So you create class methods using the method keyword. Alternatively, you can use procedure or function if you want the compiler to enforce returning or not returning a value.

[function/procedure] RoutineName : ReturnType; 

As with C++, your custom routine must come before it's first usage or you have to prototype it in the Interface section.

method Form1.IntroduceYourself;
begin
  MessageBox.Show("Hello, I do not have a name yet.");
end; 
 
procedure Form1.SayHello(pName: String);
begin
  MessageBox.Show("Hello " + pName);
end;

function Form1.Add(p1, p2 : Double): Double;
begin
  Result := p1 + p2;
end;

 Delphi Prism Custom Routines (method, procedure, function)

The Prism event handler is based on the .Net event handler.

Most notable for Delphi developers is the fact that Prism does not offer initialization nor finalization sections.

Prism does not support Delphi's asm keyword. Since all the .Net languages compile into intermediate language (IL), and not to a specific CPU, they do not provide support for inline assembler code.

In Prism, inlining is automatically done for you by the JIT compiler for all languages and in general leads to faster code for all programmers whether they are aware of inlining or not.

ASP Classic does not support any type of overloading.

• Operator - No.
• Method - No.

Some developers like to pass in an array and then handle the array for a pseudo technique. Although not overloading, it's useful.

 ASP Classic Overloading (Not Supported)

Like Delphi, Prism supports overloading. However, Prism supports implicit overloading (no need for an overload keyword).

method MainForm.Add(a, b: integer): Integer;
begin
  Result := a + b;
end;

method MainForm.Add(const msg: String; a, b: integer): String;
begin
  Result := msg + (a + b);
end;

 Delphi Prism Overloading (implicit)

By Reference or Value
For parameters, you can optionally specify ByVal or ByRef. ByRef is the default if you don't specify.

Syntax Example:   Function SomeRoutine(ByRef pPerson, ByVal pName, Age)

Defining
Prism allows parameters of the same type to be listed together, separated by commas, and followed with a single data type (more params of different data types can follow, after a semi-colon).

By Reference or Value (and by constant and out)
The default for parameters is by value. For by reference, add var in front of the parameter. Prism also offers constant parameters where you add const in front of the parameter. A constant parameter is like a local constant or read-only parameter the compiler can optimize. You cannot assign a value to a constant parameter, nor can you pass one as a var parameter to another routine. (But when you pass an object reference as a constant parameter, you can still modify the object's properties.) Finally, Prism offers an out parameter type which is like a var parameter except it does not have to be initialized prior.

Syntax Example:   function Add(a, b: integer) : integer; begin   Result := a + b; end;   procedure ReplaceTime(var pDT: TDateTime; const pNewDT: TDateTime); begin end;

Same as VB. The Me keyword is a built-in variable that refers to the class where the code is executing.

Class Cyborg
 Public CyborgName
 

 Public Function IntroduceYourself() 
  'Using Me. Prints Cameron.
  Response.Write("Hi, my name is " & Me.CyborgName & ".")

  'The above is just a demo. You could also not include "Me." 

  'in this case because we are in context of Me now. Using Me 

  'makes more sense when you start to pass Me as a parameter 

  'to a method.

 End Function 
End Class

Within the implementation of a method, the identifier Self references the object in which the method is called. The Self variable is an implicit parameter for each object method. A method can use this variable to refer to its owning class.

To refer to the current instance of a class or structure, use the Self keyword. It provides a way to refer to the specific instance in which the code is currently executing. It is particularly useful for passing information about the currently executing instance.

You cannot use it with static method functions because static methods do not belong to an object instance. If you try, you'll get an error.