2013-03-06 19 views
9

Ho un po 'di problemi nel progettare una classe. Creazione di una classe cliente sembra semplice:Come costruire un oggetto con molte proprietà?

TCustomer = Class 
    private 
    FIdNumber: String; 
    FName: String; 
    procedure SetName(const Value: String); 
    procedure SetNumber(const Value: String); 
    public 
    Property Name : String read FName; 
    Property IdNumber : String read FIdNumber; 
    Constructor Create(Number, Name : String); 
end; 

constructor TCustomer.Create(ANumber, AName: String); 
begin 
    SetName(AName); 
    SetNumber(ANumber); 
end; 

MyCustomer := TCustomer.Create('1', 'John Doe'); 

Ma bene il mio cliente ha più proprietà: dove vive, la data di nascita ecc ecc

TCustomer = Class 
    private 
    {..snip snip..} 
    public 
    Property Name : String read FName; 
    Property IdNumber : String read FIdNumber; 
    Property Street : String read FStreet; 
    Property HouseNumber : Integer : read FHouseNumber; 
    .. 
    .. 
    .. 
    Constructor Create(Number, Name, Street : String; Housenumber : Integer .. .. ..); 
end; 

Come vedi io alla fine con un costruttore con un sacco di argomenti. Qual è un modo migliore per costruire un oggetto con molte proprietà?

+4

mio thoght iniziale è quello di costruire la classe solo con le proprietà essenziali * * che mantengono la creazione istanza di classe. per esempio nel tuo caso potrebbe essere un 'ID utente 'univoco. – kobik

+2

È possibile rendere analogo il proprio caso alla creazione di un nuovo record DB ('insert'). Pensa quali proprietà sono * richieste * (usale negli argomenti del costruttore) e quali proprietà hanno i valori predefiniti (inizializzale all'interno del costruttore della classe). – kobik

+1

è possibile definire un ** costruttore ** che utilizza una serie di coppie e utilizza RTTI, si analizza la classe TCustomer e si impostano i valori dei campi dai parametri, ad esempio TMyCustomer.Create ([AProp ('FirstName', 'Joe'), AProp ('LastName', 'Doe'), ...]); – ComputerSaysNo

risposta

15

Se una certa classe ha bisogno di avere molti campi, vorrei fare un costruttore con solo i parametri obbligatori e il resto vorrei tenere nelle proprietà scrivibili:

type 
    TCustomer = class 
    private 
    FName: string; 
    FIdNumber: string; 
    FStreet: string; 
    FHouseNumber: Integer; 
    public 
    // constructor is empty or just with mandatory parameters 
    constructor Create; 
    // properties are writeable 
    property Name: string read FName write FName; 
    property IdNumber: string read FIdNumber write FIdNumber; 
    property Street: string read FStreet write FStreet; 
    property HouseNumber: Integer read FHouseNumber write FHouseNumber; 
    end; 

Questo naturalmente dipende, se è possibile esporre quelle proprietà in modo da essere accessibile in scrittura, ma l'utilizzo appare a mio avviso meglio di costruttore con molti parametri:

var 
    Customer: TCustomer; 
begin 
    Customer := TCustomer.Create; 
    Customer.Name := 'Name'; 
    Customer.IdNumber := 'ID number'; 
    Customer.Street := 'Street'; 
    Customer.HouseNumber := 12345; 
end; 
+6

+1 solo per menzionare possiamo fare diversi 'overload's del' costruttore 'se necessario ("costruttore è vuoto o solo con parametri obbligatori") – kobik

+0

I setter di proprietà fluenti possono essere usati anche se semplici con/do probabilmente fornirebbe un codice altrettanto conciso e più sicuro –

Problemi correlati