Objektorientierung und Serialisierung

Question

Betrachten Sie eine Schnittstelle wie

IMyInterface = interface 
    procedure DoSomethingRelevant; 
    procedure Load (Stream : TStream); 
    procedure Save (Stream : TStream); 
end; 

und mehrere Klassen, die die Schnittstelle implementieren:

TImplementingClass1 = class (TInterfacedObject, IMyInterface) 
    ... 
end; 
TImplementingClass2 = class (TInterfacedObject, IMyInterface) 
    ... 
end; 
... 

Ich habe eine Klasse, die eine Liste von IMyInterface Implementierer hat:

TMainClass = class 
strict private 
    FItems : TList <IMyInterface>; 
public 
    procedure LoadFromFile (const FileName : String); 
    procedure SaveToFile (const FileName : String); 
end; 

Nun zur Frage: Wie kann ich die Hauptklasse und vor allem die Objektliste in ein Objekt-Orientierungssystem laden ed-Art? Bevor ich die virtuelle Load-Methode für die Elemente aufrufen kann, muss ich sie erstellen und muss daher deren Typ kennen. In meiner aktuellen Implementierung speichere ich die Anzahl der Elemente und dann für jedes Element

• eine Typkennung (IMyInterface bekommt eine zusätzliche GetID Funktion)
• Aufruf der Save-Methode des Elements

Aber die während des Ladens bedeutet, dass ich so etwas wie

ID := Reader.ReadInteger; 
case ID of 
    itClass1 : Item := TImplementingClass1.Create; 
    itClass2 : Item := TImplementingClass2.Create; 
    ... 
end; 
Item.Load (Stream); 

zu tun haben, aber das ist nicht zu sehr objektorientiert scheint, da ich mit vorhandenen Code Geige haben allen Zeit füge ich einen neuen Implementor hinzu. Gibt es einen besseren Weg, um mit dieser Situation umzugehen?

Answer 1

Eine Lösung wäre, eine Factory zu implementieren, in der alle Klassen sich mit einer eindeutigen ID registrieren.

TCustomClassFactory = class(TObject) 
public  
    procedure Register(AClass: TClass; ID: Integer); 
    function Create(const ID: Integer): IMyInterface; 
end; 

TProductionClassFactory = class(TCustomClassFactory) 
public 
    constructor Create; override; 
end; 

TTestcase1ClassFactory = class(TCustomClassFactory); 
public 
    constructor Create; override; 
end; 

var 
    //***** Set to TProductionClassFactory for you production code, 
    //  TTestcaseXFactory for testcases or pass a factory to your loader object. 
    GlobalClassFactory: TCustomClassFactory; 

implementation 

constructor TProductionClassFactory.Create; 
begin 
    inherited Create; 
    Register(TMyImplementingClass1, 1); 
    Register(TMyImplementingClass2, 2); 
end; 

constructor TTestcase1ClassFactory.Create; 
begin 
    inherited Create; 
    Register(TMyImplementingClass1, 1); 
    Register(TDoesNotImplementIMyInterface, 2); 
    Register(TDuplicateID, 1); 
    Register(TGap, 4); 
    ... 
end; 

Vorteile

• Sie können die bedingte Logik von Ihrer aktuellen Lademethode entfernen.
• Ein Ort, um nach doppelten oder fehlenden IDs zu suchen.

Answer 2

Sie benötigen eine Klassenregistrierung, in der Sie jede Klassenreferenz zusammen mit ihrer eindeutigen ID speichern. Die Klassen registrieren sich im Initialisierungsabschnitt ihrer Einheit.

TImplementingClass1 = class (TInterfacedObject, IMyInterface) 
    ... 
end; 
TImplementingClass2 = class (TInterfacedObject, IMyInterface) 
    ... 
end; 

TMainClass = class 
public 
    procedure LoadFromFile (const FileName : String); 
    procedure SaveToFile (const FileName : String); 
end; 

Edit: bewegt, um die Klasse Registrierung in eine separate Klasse:

TMyInterfaceContainer = class 
strict private 
class var 
    FItems : TList <IMyInterface>; 
    FIDs: TList<Integer>; 
public 
    class procedure RegisterClass(TClass, Integer); 
    class function GetMyInterface(ID: Integer): IMyInterface; 
end; 

procedure TMainClass.LoadFromFile (const FileName : String); 
    ... 
    ID := Reader.ReadInteger; 
    // case ID of 
    // itClass1 : Item := TImplementingClass1.Create; 
    // itClass2 : Item := TImplementingClass2.Create; 
    // ... 
    // end; 
    Item := TMyInterfaceContainer.GetMyInterface(ID); 
    Item.Load (Stream); 
    ... 

initialization 
    TMyInterfaceContainer.RegisterClass(TImplementingClass1, itClass1); 
    TMyInterfaceContainer.RegisterClass(TImplementingClass2, itClass2); 

Diese Sie in die Richtung zeigen sollte, für eine sehr gute Einführung in diese Methoden die berühmte Martin Fowler article lesen, esp. der Abschnitt über Interface Injection