Código Delphi [-]
unit UMyObjectInterface;

interface

type
  // se define una interface con los procedimientos/funciontes
  IMyInterface = interface(IInterface)
    ['{ECEF5846-F1B3-4ECE-9113-16B2C7962F04}']
    function algoMas: integer;
    procedure mostrar;
  end;

  // se define una Objeto abstracto con los metodos de la interface
  TMyAbstractObject = class abstract (TInterfacedObject, IMyInterface)
    function algoMas: integer; virtual; abstract;
    procedure mostrar; virtual; abstract;
  end;

  // se define el puntero a la clase abstracta del objeto
  TClassMyObject = class of TMyAbstractObject;

  // se define la funcion para la importacion/exportacion de la clase
  TGetMyExportedObject = function: TClassMyObject; cdecl;

implementation

end.

Código Delphi [-]
unit Unit1;

interface

 uses
   Windows, Messages, SysUtils, Variants, Classes,
   DateUtils, UMyObjectInterface;

type
  TMyObject = class(TMyAbstractObject)
    function algoMas: integer; override;
    procedure mostrar; override;
  end;

  function GetMyExportedClass: TClassMyObject; cdecl;

exports
 GetMyExportedClass;

implementation

uses
  Vcl.Dialogs;

// función que devuelve el puntero a la clase del objeto
function GetMyExportedClass: TClassMyObject; cdecl;
begin
  Result := TMyObject;
end;


{ TMyClass }
function TMyObject.algoMas: integer;
begin
  Result := 123456;
end;

procedure TMyObject.mostrar;
begin
  inherited;
  MessageDlg('Hola mundo!!!', mtInformation, [mbOK], 0);
end;

end.

Código Delphi [-]
unit UMyObjectInDLL;

interface

uses UMyObjectInterface;

var
  TMyObjectDLL: TClassMyObject = Nil;

implementation

uses
{$ifdef fpc}
 dynlibs,
{$endif}
  Winapi.Windows, System.SysUtils;


var
  {$ifdef fpc}
  mHandle: TLibHandle = NIL;
  {$else}
  mHandle: THandle = 0;
  {$endif}
  _EC: TGetMyExportedObject = Nil;

initialization
  (* load shared library *)
  if (pointer(mHandle) = nil) then begin
    (* Try to load shared library *)
    mHandle := LoadLibrary('MiClassDLL.dll');
    if (pointer(mHandle) = nil) then
      raise Exception.Create('No se ha podido cargar la DLL')
    else begin
      (* instantiate a TMyExportedClass object *)
      _EC := GetProcAddress(mHandle, 'GetMyExportedClass');
      if (pointer(@_EC) = nil) then
        raise Exception.Create('No se ha podido cargar la funcion GetMyExportedClass')
      else
        TMyObjectDLL := _EC;
    end;
  end;

finalization
  (* unload shared library *)
  {$ifdef fpc}
  UnLoadLibrary(mHandle);
  {$else}
  FreeLibrary(mHandle);
  {$endif}
end.

Código Delphi [-]
...
uses
  UMyObjectInterface,
  UMyObjectInDLL;

procedure TMainForm.Button1Click(Sender: TObject);
var
  myObj: TMyAbstractObject;
begin
    /// Inicializar la clase exportada
    myObj := TMyObjectDLL.create;
    try
      MessageDlg(IntToStr(myObj.AlgoMas), mtInformation, [mbOK], 0);
      myObj.mostrar;
    finally
      (*... and free exported class *)
      myObj.free;
    end;
end;

Código Delphi [-]
uses UMyObjectInDLL, UMyObjectInterface;

type
  TOtraMyClass= class(TMyObjectDll)
    procedure Procedimiento2;
  end;

Código Delphi [-]
var   TMyObjectDLL: TClassMyObject = Nil;

Código Delphi [-]
myObj := TMyObjectDLL.create;

Código Delphi [-]
TOtraMyClass= class(TMyObjectDll)

Código Delphi [-]
   TOtraMyClass= class(TClassMyObject )

Código Delphi [-]
myObj := TMyObjectDLL.create;

Código Delphi [-]
myObj := TClassMyObject.create;

Código Delphi [-]
   TOtraMyClass= class(TClassMyObject )

Código Delphi [-]
  function MiFuncion : string; stdcall; external 'MiDll.dll';

Código Delphi [-]
  TMyObjectDLL = class stdcall; external 'MiDll.dll';