Create wird nicht aufgerufen bei Klassen-Chaos

[glkgereon]

Hi

ich schreibe grade an einer Importer-Klasse...
Diese soll möglichst einfach erweiterbar sein, daher habe ich mir folgendes Konzept ausgedacht:
Eine virtuelle Basisklasse, und mehrere Klassen, die diese Implementieren, für jeden Datentyp einen.

Code:

Delphi-Quellcode:

type
  TImport_Virtual = class(TObject)
  private //Basisklasse für ImportTyp
    FFileName: String;
    FFileExt: String;
  public
    FData: TDataArray;
    function OpenFile(var Err: String):Boolean; virtual; abstract;
    function CloseFile(var Err: String):Boolean; virtual; abstract;
    function Analyse(var Err: String):Boolean; virtual; abstract;
    function GetData(var Dat: TDataArray):Boolean;
    property FileName: String read FFileName write FFileName;
  end;

  TImportClassType = class of TImport_Virtual;

  TDBFImport = class(TImport_Virtual)
  private //Import aus DBF-Datei
    FDBF: TDBFFile;
  public
    constructor Create;
    destructor Destroy;
    function OpenFile(var Err: String):Boolean; override;
    function CloseFile(var Err: String):Boolean; override;
    function Analyse(var Err: String):Boolean; override;
  end;


type
  TImport = TImport_Virtual;

Als erstes die Basisklasse, dann eine Implementation für ein DBF-File.

So rufe ich das ganze auf:

Delphi-Quellcode:

Typ:=GetImportType(Edt_FileName_Man.FileName);
    if Typ=nil then
      begin
      Log('Importer laden',True,cEFileExt);
      Exit;
      end
    else
      Log('Importer laden',False,'');

    Import:=Typ.Create;

GetImportType gibt den zu der Endung passenden Importer zurück...das klapp auch. in Classname steht auch TDBFImport drin!

Delphi-Quellcode:

  TImportType = record //Import-Typ
    Import: TImportClassType;
    FileExt: String;
    Description: String;
  end;

  TImportArray = array[0..0] of TImportType;

const //Import-Typen
  cImports: TImportArray = (
  (Import: TDBFImport; FileExt: '.dbf'; Description: 'DBF-Datei')
  );

function GetImportType(FileName: String): TImportClassType;
var Ext: String;
    i, ID:Integer;
begin
  Ext:=LowerCase(ExtractFileExt(FileName));
  ID:=-1;
  for i:=0 to Length(cImports)-1 do
    if LowerCase(cImports[i].FileExt)=Ext then ID:=i;
  if ID=-1 then
    Result:=nil
  else
    Result:=cImports[ID].Import;
end;

Nun setze ich im OnCreate der Implementation FFileExt auf die jeweilige Endung (hier '.dbf')
Allerdings wird dieses Create nie aufgerufen!

hat irgendeiner eine Idee warum das so ist?

[omata]

Ich habe keine Ahnung was du da machst, aber wäre ein override beim Konstruktor vielleicht hilfreich?

Edit: Oh, beim Destruktor auf jeden Fall!

MfG
Thorsten

[Khabarakh]

Genau. Aus diesem Grund ist auch der Konstruktor von TComponent virtuell.

[glkgereon]

Geht nicht.

[Fehler] UImport.pas(36): E2170 Eine nichtvirtuelle Methode kann nicht überschrieben werden

und wenn ich in der Basisklasse auch ein virtual; abstract; Create einfüge, so kommt ein Abstrakter Fehler...

[Khabarakh]

Ganz sicher, dass in der Variable eine Klasse ungleich der Basisklasse ist und deren Konstruktor mit override markiert ist?

[glkgereon]

Ja.

Typ.ClassName ist eindeutig TDBFImport.
Import.ClassName übrigens auch

[Khabarakh]

Du hast mich so verunsichert, dass ich es selbst ausprobiert habe ^^ .

Delphi-Quellcode:

type
  TBase = class
  public
    constructor Create; virtual; abstract;
  end;

  TDescendant = class(TBase)
  public
    constructor Create; override;
  end;

  TBaseClass = class of TBase;
  
implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
var
  c: TBaseClass;
begin
  c := TDescendant;
  c.Create;
end;

Funktioniert wie erwartet .

[omata]

Oh, habe mich oben verschrieben. (ist jetzt korrigiert)
Ich meinte natürlich beim EDIT den Destruktor!

MfG
Thorsten

[Muetze1]

Es muss vor allem nur ein virtueller Constructor Create definiert werden in der TImport_Virtual - kein abstrakter!

Die Ableitungen müssen ihn überschreiben und dann wird dieser auch aufgerufen...

[tomsel]

Zitat von Muetze1:

Es muss vor allem nur ein virtueller Constructor Create definiert werden in der TImport_Virtual - kein abstrakter!

Die Ableitungen müssen ihn überschreiben und dann wird dieser auch aufgerufen...

Genau! Die Variable "Import" ist ja wohl vom Typ TImport_Virtual. Da TImport_Virtual den Construktor von TObject nicht überschreiben kann, ihn aber auch nicht verdeckt, wird halt TObject.Create aufgerufen.