Cross Ref > OOP Details

C# supports abstract class members and abstract classes using the abstract modifier.

An abstract class is a class with one or more abstract members and you cannot instantiate an abstract class. However, you can have additional implemented methods and properties.

An abstract member is either a method (implicitly virtual), property, indexer, or event in an abstract class. You can add abstract members ONLY to abstract classes using the abstract keyword. Then you override it in a descendant class with Override.

abstract public class Cyborg : System.Object

{

  abstract public void Speak(string pMessage);

}

public class Series600 : Cyborg

{

  public override void Speak(string pMessage)  

  {

    MessageBox.Show(pMessage);  

  }

}

 C# Abstraction (abstract, override)  

Delphi for Win32 supports abstract class members using the abstract keyword. You can even instantiate instances of a class that contains abstract members. Then you override each abstract member in a descendant class with Override.

Delphi does not support setting an entire class as abstract. You can create an abstract class (a class with one or more abstract methods), but there is no way to tell the compiler to not allow the instantiation of the abstract class.

Delphi does not support abstract member properties directly. To implement an abstract properity, make use of abstract methods. That is, you can read a GetPropertyX abstract function and write to a SetPropertyX abstract procedure. In effect, creating  an abstract property.

TCyborg = class(TObject)
public
  procedure Speak(pMessage: String); virtual; abstract;
  procedure Walk; virtual; abstract;
end;

TSeries600 = class(TCyborg)
public
  procedure Speak(pMessage: String); override;
  procedure Walk; override;
end;

 Delphi Abstraction (abstract, override)

However, developers sometimes use the term "class helper" to refer to code that helps out a class. Not truly the meaning we are using here, but you should be aware of the term's general usage.

Delphi allows you to extend an existing class without using inheritance. Buggy in 2005 and not officially supported but stable, usable, and officially supported in 2006 and above.

You declare a class helper similiar to how you declare a class but use the keywords class helper for.

TCyborg = class(TObject)
public
  FCyborgName: String;
end;

TCyborgHelper = class helper for TCyborg
  procedure ShowClassName;
end;

 Delphi Class Helpers (class helper for)  

Although not currently supported, there are plans for the next version of VS.Net and .Net using Requires and Ensures keywords. Look for code contracts in VS.Net 2010 and .Net 4.

• Read About It: Introduction to Code Contracts

If you code with VS.Net 2008 Pro or above and wish to implement contracts now, checkout the following download:

• Managed Contract Tools

//Future syntax may look something like:

string SetAge(int pAge) { 
  Contract.Requires(pAge>0);
}

string GetAge() { 
  Contract.Ensures(Contract.Result() != null);

}

Delphi does not offer built-in Design by Contract features. It does offer an Assert method which tests if an expression is true. If false, an EAssertionFailed exception is raised. Although you can use Assert in a similar manor as you would use a pre-condition contract, the Delphi help clearly says Assert is a debugging tool only and to not use it in production code.

//Although not intended as a code contract feature,

//Assert is useful for debugging.

method Cyborg.Walk(pPace);

begin
  Assert(pPace > 0);
  Assert(pPace < 100);

  //Overloaded version with message.
  Assert(FEnergyLevel >= 10, 'Energy level too low.');
end;

In C#, a constructor is called whenever a class or struct is created. A constructor is a method with the same name as the class with no return value and you can overload the constructor.

If you do not create a constructor, C# will create an implicit constructor that initializes all member fields to their default values.

Constructors can execute at two different times. Static constructors are executed by the CLR before any objects are instantiated. Regular constructors are executed when you create an object.

public class Cyborg
{
  public string CyborgName;

  //Constructor.

  public Cyborg(string pName)
  {
    CyborgName = pName;
  }
}

 C# Constructors (Use class name)  

In Delphi, use the constructor keyword to signify which method or methods are constructors for a class. It is traditional but not required to use a procedure called Create.

In addition to having multiple named constructors, you can overload constructors.

//Interface section.

TCyborg = class(TObject)
public
  constructor Create;
end; 

constructor TCyborg.Create;
begin
  inherited;  //Call the parent Create method

end;

 Delphi Constructors (constructor)  

In C# you cannot explicitly destroy a managed object. Instead, the .Net Framework's garbage collector (GC) takes care of destroying all objects. The GC destroys the objects only when necessary. Some situations of necessity are when memory is exhausted or you explicitly call the System.GC.Collect() method. In general, you never need to call System.GC.Collect().

In .Net, a finalizer is used to free non-managed objects such as a file or network resource. In C#, a finalizer is a method with the same name as the class but preceded with a tilde (as in ~ClassName). The finalizer method implicity creates an Object.Finalize method (you cannot directly call nor override the Object.Finalize method). Because you don't know when the garbage collector will call your finalizer, Microsoft recommends you implement the IDisposable interface for non-managed resources and call it's Dispose() method at the appropriate time.

class Cyborg {
public:
  //Destructor for class Cyborg.
  ~Cyborg();

  {

  //Free non-managed resources here.

  }
};

 C# Finalizer (~ClassName)  

Object Pascal uses a standard virtual destructor named Destroy which is called by the standard Free method. All objects are dynamic, so you need to call MyObject.Free method or the FreeAndNil(MyObject) routine for each object you create.

Syntax Example:   var MyObject: TObject; begin MyObject := TObject.Create; //Use it... MyObject.Free //Or use...FreeAndNil(MyObject); end;

C# does not support multiple implementation inheritance. Each class can have only one parent class (a single inheritance path). In C#, you can use multiple interface usage to design in a multiple class way horizontally in a class hierarchy.

Delphi does not support multiple implementation inheritance. Each class can have only one parent class (a single inheritance path).

In Delphi, you can use multiple interface usage to design in a multiple class way horizontally in a class hierarchy.

Classes and structs can inherit from interfaces in a manner similar to how classes can inherit a base class or struct, but a class or struct can inherit more than one interface and it inherits only the method names and signatures, because the interface itself contains no implementations.

class MyClass: IMyInterface

{  

  public object Clone()
  {
  return null; 
  }  

// IMyInterface implemented here...
} 

interface IMyInterface

{

  bool IsValid();

}

 C# Interfaces (interface)

In Delphi, you use interfaces for both com objects and language interfaces and make use of IUnknown, IInterface, and/or TInterfacedObject.

For a pure language interface, add your specified proprieties, procedures, and functions to an interface that descends from IInterface (the base interface) as an interface, no implementation. Then have your implementing class inherit from TInterfacedObject and implement the interface.

For extending the VCL, you descend from the class you wish to extend, then implement an interface from IInterface and add the required functions QueryInterface, _AddRef, and _Release methods (refer to TInterfacedObject for an example).

For a com object, you descend from IUnknown. Descending from IUnknown instead of IInterface informs the Delphi compiler that the interface must be compatible with COM objects -- a Windows feature).

When defining an interface, define it in the type block just like you do for a class but you use the interface keyword instead of the class keyword and in the interfaces section only. Since interfaces, by definition, do not have any implementation details, all you do is specify it in the type block. Then implement in all classes that support the interface.

//Language interface:

//Interface section of unit.

IHuman = Interface(IInterface)
  //Specify interface methods and properties here.

end;

TCyborg = class(TInterfacedObject)

end;

TCyborgHuman = class(TCyborg, IHuman)
  //Specify each here and implement in
  //implementation section.
end;

 Delphi Interfaces (IInterface, TInterfacedObject)

In C#, you specify a virtual method with the virtual keyword in a parent class and extend (or replace) it in a descendant class using the override keyword.

Use the base keyword in the descendant method to execute the code in the parent method, i.e. base.SomeMethod().

class Robot

{

  public virtual void Speak()

  {

  }
}
 

class Cyborg:Robot

{

  public override void Speak()

  {

  }
}

 C# Overriding (virtual, override)

In Delphi, you specify a virtual method with the virtual keyword in a parent class and extend (or replace) it in a descendant class using the override keyword. Call Inherited in the descendant method to execute the code in the parent method.

TRobot = class(TObject)
public
  procedure Speak; virtual;
end;

TCyborg = class(TRobot)
  procedure Speak; Override;
end;

 Delphi Overriding (virtual, override)

C# uses the keyword partial to specify a partial class. All parts must be in the same namespace.

class partial Cyborg: System.Object

{

}

 C# Partial Classes (partial)  

As of Delphi 2009, partial classes are not supported. The main reason given in the thread below was that the Delphi compiler is a single pass compiler. Here is a link to a discussion thread on the subject:

• Delphi language (partial classes)

C# supports the following types of polymorphism:

• Parametric Polymorphism (Method Overloading)
• Inheritance-Based Polymorphism
• Interface-Based Polymorphism (Interfaces)
• Ad-Hoc Polymorphism (Operator Overloading)
  

Delphi supports the following types of polymorphism:

• Parametric Polymorphism (Method Overloading)
• Inheritance-Based Polymorphism
• Interface-Based Polymorphism (Interfaces)
• Ad-Hoc Polymorphism (Operator Overloading)

With C#, use the sealed keyword to prevent a class from being inherited from and to prevent a method from being overridden.

A method marked sealed must override an ancestor method. If you mark a class sealed, all members are implicitly not overridable so the sealed keyword on members is not legal.

public class Machine : System.Object
{
  public virtual void Speak(String pSentence)
  {
    MessageBox.Show(pSentence);
  }
}
    
public class Robot : Machine
{
  public sealed override void Speak(String pSentence)
  {
    MessageBox.Show(pSentence);
  }
}

public sealed class Cyborg : Robot
{ 
}

With Delphi, use the sealed keyword to prevent a class from being inherited from and use the final keyword to prevent a method from being overridden.

type

  Robot = class sealed(TObject)
  public
    procedure Speak(pSentence: String); virtual; final;
  end;

 Delphi Sealed class (sealed, final)  

C# supports both static members and static classes using the static keyword. You can add a static method, field, property, or event to an existing class. Also, you can designate a class as static and the compiler will ensure all members in that class are static. You can add a constructor to a static class to initialize values.

The CLR automatically loads static classes with the program or namespace.

//Static Class Example
public static class MyStaticClass
{

  //Static Method Example

  public static void MyStaticMethod()
  {
  // static method code
  }

}

 C# Static Members (static)

Object Pascal supports static methods, but not static member fields. For static member fields, use traditional Pascal-like global variables.

Since Object Pascal is a hybrid language, you can use global functions and data so the need for class methods is diminished but still useful. For example, since Object Pascal does not have automatic reference counting, you could use a class method to keep track of the number of object instances.

Delphi 1-7: All classes in a unit are friendly (see eachother's private members), some developers like to put each class in it's own unit and reserve putting multiple classes in the same unit until they wish to implement friendly classes.

Delphi 2005+: New strict keyword allows you to indicate friendly.

Delphi Prism: The Strict keyword was introduced from the beginning (Delphi.Net preview that shipped with D7).

type
TMyUtils = class(TObject)
public
  class function MyStaticMethod: Integer;
end;

class function TMyUtils.MyStaticMethod: Integer;

 Delphi Class Members (Class)