Conosco interfacce, classi astratte che servono come classe base, ho letto su accoppiamenti lenti, ... ma non riesco a trovare una soluzione decente quando una proprietà di una classe cambia, e il nuovo tipo deve essere implementato in altre classi utilizzando questa classe aggiornata.
Esempio
Di seguito è una rappresentazione semplificata di una situazione di vita reale. La fattura contiene un oggetto Contatto con una proprietà Indirizzo.
Abstract Class Contact{
string Name{get;set;}
string Address{get;set;}
}
Class Customer:Contact{
string CustomerNumber{get;set;}
}
Class Invoice{
string DocumentNumber{get;set;}
Customer Customer{get;set;}
}
Successivamente, decidiamo di aggiornare la classe Contact per contenere più indirizzi. Di cui la fattura ne avrà bisogno.
Class Address{
string Street{get;set;}
}
Abstract class Contact{
string Name{get;set;}
List<Address> Addresses{get;set;}
}
Logicamente, la classe Invoice deve essere cambiata in qualcosa di simile a
Class Invoice{
string DocumentNumber{get;set;}
Customer Customer{get;set;}
Address InvoiceAddress{get;set;}
}
problema
Immediatamente vedi che ovunque ho usato la proprietà string Address prima, ora dovrò cambiarlo in un occorrenza del tipo Indirizzo
Come affermato in precedenza, questo è solo un esempio semplificato. Il vero problema della vita sarebbe molto, molto più grande in quanto i contatti saranno utilizzati nell'intero software.
Conclusione
Voglio sviluppare il software con un principio che manterrà il mio software leggero per le nuove versioni di determinati moduli. In questo modo, se decido di creare un nuovo modulo Contatti, l'impatto sugli altri moduli è quasi inesistente. Quindi, la funzionalità aggiunta può essere implementata gradualmente.
Voglio sapere come posso affrontare questi problemi di versioning. Questo progetto è attualmente ancora in fase di progettazione architettonica e desidero risolverlo prima di continuare.