Typ in Variable speichern

[glkgereon]

Hi

ich möchte Daten aus mehreren verschiedenen Formaten laden.
Dazu habe ich mir folgendes Konzept überlegt:

Ich habe eine Basisklasse TImport und davon abgeleitete Importklassen wie z.B. TXLSImport oder TCSVImport.
Nun schreibe ich mir einen Record TImportType mit der Dateiendung, einer Beschreibung und dem zugehörigen Typen.
Also zum Beispiel 'xls','Excel-Datei',TXLSImport.
Wenn ich nun einen Array anlegen würde, indem alle Importtypen drinstehen, so könnte ich beim Laden einfach dieses Array durchgehen und, sobald ich die passende Dateiendung gefunden hab, eine Instanz des entsprechenden Importers erstellen, und mithilfe der in der Basisklasse deklarierten Methoden die entsprechenden Daten laden.

Die Frage(n) dazu:
Ist soetwas grundsätzlich möglich?
Wie kann ich einen Typen hinterlegen?
Und last, but not least: Wie sähe das ganze konkret als Code aus?

[Der_Unwissende]

Zitat von glkgereon:

Die Frage(n) dazu:
Ist soetwas grundsätzlich möglich?
Wie kann ich einen Typen hinterlegen?
Und last, but not least: Wie sähe das ganze konkret als Code aus?

Ja, es ist prinzipiell Möglich.
Einen solchen Typen musst du als Metaklasse (class of <Type>) hinterlegen

Delphi-Quellcode:

  // Deine Basisklasse
  TImport = class(TObject)
  end;
  
  // Meta-Klasse
  TImportClass = class of TImport;

  // Ersetzt eigentlich nur deinen Record, erklär noch warum
  TImportType = class(TObject)
    private
      // Die gespeicherte Basisklasse (also auch ein Nachfahre)
      FClassType : TImportClass;
      // Die Beschreibung
      FDescription : String;
    public
      constructor create(classType : TImportClass; Description : String);
      property classType : TImportClass read FClassType;
      property description : String read FDescription;
  end;

So, dass sind die Typen die du anlegen musst. Ich hab TImportType einfach mal zu einer Klasse gemacht, da man so leicht dein Array durch ein TStrings ersetzen kann. Ist der Zugriff einfach nur schöner als wenn du jetzt über ein Array iterierst.
Ach ja, classType ist schlecht gewählt, gibt es schon bei TObject, sollte also umbenannt werden.

Delphi-Quellcode:

// Eintragen
var stringList : TStringList; // natürlich etwas globaler
    classType : TImportClass;
    description : String;
    DateiEndung : String;
begin
  // Stringlist erzeugen
  stringList := TStringList.Create;

  // Für jede Dateiendung die dazugehörige Instanz von TImporttype speichern
  DateiEndung := 'xls'; // Dateiendung festlegen
  Description := 'MS Excel Datei'; // Beschreibung für die DateiEndung
  classType := TXLSImport;
  stringList.AddObject(DateiEndung, TImportType.Create(classType, description));

  // ...
  // ...
end; 

// Und für einen Dateityp den import durchführen
var instanz : TImport;
begin
  // Schaut in der Stringlist nach, ob es den Eintrag DateiEndung gibt. Holt das Objekt, dass an dieser Stelle steht 
  // Castet dieses Objekt zu TImportType, nimmt die gespeicherte Meta-Klasse und erzeugt eine Instanz von ihr
  instanz := TImportType(stringList.Objects[stringList.IndexOf(DateiEndung)]).classType.Create;
  // instanz enthält jetzt eine zur Dateiendung gehörige Instanz
end;

So, nicht ganz sauber, aber kannst du ja sicher leicht verbessern. Solltest auf jedenfall prüfen ob es überhaupt einen Eintrag zu der Dateiendung gibt, bevor du auf classType zugreifen möchstest. Sonst gibt's wohl ne AV.

Hoffe es hilft weiter,
Gruß Der Unwissende

[glkgereon]

Hey super.

Das werde ich dann mal in aller ausführlichkeit testen

Ich melde mich wenns noch Fragen gibt

PS:
Also von der Möglichkeit mit der TStringList werde ich wohl absehen...soll eh konstant werden...mal gucken ob das geht


Edit: SUPI

also so scheint es zu gehen (Für alle, die dieses Problem auch haben (werden)):

Delphi-Quellcode:

  TImport_Virtual = class(TObject)
  private //Basisklasse für ImportTyp
    FFileName: String;
    FFileExt: String;
    FData: TDataArray;
  public
    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;

  TXLSImport = class(TImport_Virtual)
  private //Import aus XLS-Datei
    Adv: TAdvStringGrid;
  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;

  TImportType = record
    Import: TImportClassType;
    FileExt: String;
    Description: String;
  end;

  TImportArray = array[1..2] of TImportType;

const //Import-Typen
  cImports: TImportArray = (
  (Import: TXLSImport; FileExt: 'xls'; Description: 'Excel-Datei'),
  (Import: TXLSImport; FileExt: 'xls'; Description: 'Excel-Datei')
  );

und dann der Aufruf:

Delphi-Quellcode:

procedure TForm_Main.Btn_ExecuteClick(Sender: TObject);
//Hochladen
var Import: TImport_Virtual;
    B: Boolean;
    S: String;
begin
  try
    Import:=Imports[1].Import.Create;
    Import.FileName:=Edt_FileName_Man.FileName;
    B:=Import.OpenFile(S);
    Log('Datei laden',B,S);
    B:=Import.Analyse(S);
    Log('Analyse',B,S);
    B:=Import.CloseFile(S);
    Log('Datei schließen',B,S);
    Log('Daten kopieren',Import.GetData(FData));
    Log('Upload',Upload);
    Import.Free;
  except
  end;
end;

und das raussuchen welchen index ich nun nehmen muss, das ist ja nun einfach