Cross Ref > OOP Basics

In C++/CLI, the Object keyword is an alias for the base System::Object class and is the single base class all classes ultimately inherit from.

In Prism, the Object keyword is an alias for the base System.Object class and is the single base class all classes ultimately inherit from.

Syntax Example:   //Specify both namespace and class: Cyborg = class(System.Object) end; //Use Object keyword for System.Object. Cyborg = class(Object) end; //When none, default is System.Object. Cyborg = class end;

Declare your class in the Interface section. Then implement the class in the Implementation section. To create an object instance, use the New keyword. Optionally, you can use Create for backword compatibility with Delphi if you turn it on in the compatibility options. Since Prism does have a garbage collector, you do not have to free the object. If you need to free either unmanaged resources or resources where "timing" is important, implement IDisposable and take control of freeing the object yourself using Dispose.

Cyborg = class(System.Object)
  public method IntroduceYourself();
end;

method Cyborg.IntroduceYourself();
begin
  MessageBox.Show("Hi, I do not have a name yet.");
end;

var T1: Cyborg;
begin
  T1 := New Cyborg;
  T1.IntroduceYourself;

  //No need to clean up with managed classes.

  //The garbage collector will take care of it.
end;

 Delphi Prism Class..Object (class..end..new)

In Prism, like Delphi, you use the class keyword followed by the parent class in parens. If you leave out the parent class, your class inherits from System.Object.

Android = public class

end;

T-600 = public class(Android)

end;

 Delphi Prism Inheritance (=class(ParentClass))  

Like all .Net languages, Prism events are a separate type of class member. You define a member event by using the event keyword. Events depend on Delegates to define the signature (the type) of the event they represent and they maintain a list of multiple subscribers - unlike in Delphi for Win32, where each event can only have one handler

In Prism you can set the visibility of a member field to any visibility: private, protected, public, assembly and protected or assembly or protected.

Prism supports the readonly modifier for member fields which is handy for constant like data. In this case, I chose not to preface my read-only member field with "F" so it's usage is just like a read-only property.

Prism also support the class modifier (static data) for member fields.

Delphi developers should notice the use of := to initialize a member field (in Delphi you use an =).

Cyborg = class(System.Object)
private
  FSerialNumber: String:="A100";
public
  FCyborgName: String;
  FCyborgAge: Integer:=0;
 
  class SeriesID: Integer:=100; readonly;
end;

 Delphi Prism Member Field

Prism uses the keyword method for member methods and is the preferred syntax over the legacy procedure and function keywords. Although method is preferred, you can use procedure or function if you want the compiler to make sure all functions return a value and all procedures do not.

Cyborg = class(System.Object)
  public method IntroduceYourself();
end;

method Cyborg.IntroduceYourself();
begin
  MessageBox.Show("Hi, I do not have a name yet.");
end; 

var T1: Cyborg;
begin
  T1 := New Cyborg;
  T1.IntroduceYourself;
end;

Prism supports a full suite of member modifiers. Prism virtuality modifiers are virtual, override, final, and reintroduce.

Prism general modifiers are abstract, empty, async, external, locked, unsafe, implements, and iterator.

Not all member types support all member modifiers. For example, member fields support only readonly and implements.

Cyborg = public class(System.Object)

public

  method Speak(pMessage: String); virtual;

end;

 
Series888 = public class(Cyborg)

public

  method Speak(pMessage: String); override;

end;

 Delphi Prism Member Modifiers  

 Ref: http://prismwiki.codegear.com/en/Class_Member_Modifiers

Like Delphi, Delphi Prism uses a special property keyword to both get and set the values of properties. The read and write keywords are used to get and set the value of the property directly or through an accessor method. For a read-only property, leave out the write portion of the declaration.

Prism also supports a shortcut syntax called implicit fields (known as auto-generated properties in C#):

property CyborgAge: Integer;

You can give properties any visibility you wish (private, protected, etc). It is common in Delphi and Delphi Prism to start member fields with "F" (FCName in our example) and drop the "F" with properties that manage member fields (CyborgName in our example).

Cyborg = class(System.Object)
private
  FCName: String;
public
  property CyborgName: String read FCName write FCName;
end;

In Prism, you specify each class and each class member's visibility with a Class Member Visibility Level preceding the return type. Like Delphi, you group member declarations as part of defining the interface for a class in the Interface section of a unit.

Unlike Delphi, Prism supports a traditional OO approach to member visibility with additional .Net type assembly visibility. For example, private members are truly private to the class they are declared in. In Delphi for Win32, you use strict private for true traditional private visibility.

Prism also supports assembly and protected and assembly or protected which modify the visibility of protected members to include only descendants in the same assembly (and) or publicly accessible from assembly and descendant only outside (or). OO purist might object to assembly and protected and assembly or protected and I suggest you choose the traditional private, protected, and public as your first chose at least until you both fully understand them and have a specific need for them.

Cyborg = public class(System.Object)
private

  //private properties, methods, etc. here.

  FName: String;

protected 

  //protected properties, methods, etc. here.

assembly and protected

  //properties, methods, etc. here.

assembly or protected

  //properties, methods, etc. here.

public

  //properties, methods, etc. here.

end;

 Delphi Prism Class Member Visibility Levels