orientation objet et sérialisation

Question

Considérons une interface comme

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

et plusieurs classes qui mettent en œuvre l'interface:

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

J'ai une classe qui a une liste de IMyInterface implementors:

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

Maintenant à la question: comment puis-je charger la classe principale et en particulier la liste des éléments dans un objet orienté manière ed? Avant de pouvoir appeler la méthode de chargement virtuelle pour les éléments, je dois les créer et donc connaître leur type. Dans mon implémentation actuelle je stocke le nombre d'articles et pour chaque élément

• un identificateur de type (IMyInterface obtient une fonction GetID supplémentaire)
• appel à la méthode Enregistrer de l'élément

Mais ce signifie que pendant le chargement que je dois faire quelque chose comme

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

Mais cela ne semble pas être orienté objet très que je dois jouer du violon avec le code existant tout temps, j'ajoute un nouvel implémenteur. Y a-t-il une meilleure façon de gérer cette situation?

Answer 1

Une solution serait de mettre en œuvre une usine où toutes les classes s'enregistrent avec un ID unique.

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; 

Avantages

• Vous pouvez supprimer la logique conditionnelle de votre méthode de chargement en cours.
• Un emplacement pour rechercher les ID en double ou manquants.

Answer 2

Vous avez besoin d'un registre de classes dans lequel vous stockez chaque référence de classe avec leur ID unique. Les classes s'enregistrent dans la section d'initialisation de leur unité.

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: déplacé le registre de classe dans une catégorie distincte:

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); 

Cela devrait vous indiquer dans la direction, pour une très bonne introduction dans ces méthodes lisent le célèbre Martin Fowler article, esp. la section à propos de Interface Injection