Penso che quello che potresti desiderare sia un mediatore, come da MVC. Sembra che tu stia colpendo il muro sul tuo generatore di moduli WYSIWYG e devi trasferire parte o tutto ciò che accade in un codice automatizzato.
Un buon esempio di ciò è una tastiera che stavo emulando su un modulo, quindi invece di posizionare manualmente la dimensione e la posizione di ogni chiave, faccio in modo che un algoritmo lo faccia.
Se osservi MVC, in particolare pureMVC, vedrai che un mediatore è responsabile della guida e della risposta ai controlli, quindi c'è un po 'di cablaggio da fare. Non sto dicendo che devi usare MVC, ma solo il concetto di mediatore. La sottoclassificazione di ogni controllo sembra un eccesso dalle informazioni fornite.
Possono esserci più di un mediatore per modulo. Quando eseguo MVC creerò un mediatore per ALMOST ogni controllo, eccetto i menu, che ci sarà un mediatore per ciascuno, e ogni sottomenu - e la barra degli strumenti (pulsanti) saranno tutti gestiti come un gruppo.
I mediatori sono un buon modo per isolare le responsabilità, ad esempio, puoi avere un solo mediatore responsabile del colore di sfondo delle treeliste o avere un mediatore che tenga traccia dei problemi di concentrazione.
Guardando di nuovo il tuo post, penso che probabilmente dovresti guardare in pureMVC, c'è una versione C # sul web. Se sei davvero intelligente, puoi scaricare Reflection per collegare automaticamente le cose in base ai nomi dei tuoi gestori. MVC è un buon modo per andare perché allenta l'accoppiamento del tuo codice, quindi invece di chiamare direttamente le funzioni devi solo inviare una notifica e chiunque lo 'vorrà riceverà. In questo modo non devi ricordare al punto dell'evento tutte le cose che devi fare, e tutti gli altri là fuori non devono essere presenti.
Il lato negativo è che non puoi più seguire il tuo codice saltando da una funzione all'altra in tutti i casi.
Pensaci in questo modo, ogni istanza di classe è isolata e ha bisogno di sapere molto poco sul mondo esterno - solo le convenzioni del messaggio. Quanto più velocemente puoi programmare una classe quando tutto ciò di cui si deve preoccupare è di per sé:)
pseudo-codice:
/////////////////////////////////
// I mediate a form called AppsFm
C AppsFmMed
= NAME //="AppsFmMed"
//
/////////////////////////////////
// published message
= ___P_LOAD //="AppsFmMed_LOAD"
//
/////////////////////////////////
// interested in messages;
= ___I_DATAPROXYNAME_DATACHANGED //="DataProxyName_DATACHANGED"
//
/////////////////////////////////
// my controls
p it // the form
get{return ViewForm as AppsFm;}
//
p form // the same form
p okBU // a button
get{return GetControl("okBU") as SimpleButton;}
p cancelBU // a button
p appsTL // a treelist
//
//////////////////////////////////
//ctors
Cn AppsFmMed()
Cn AppsFmMed(string mediator_name_)
Cn AppsFmMed(string mediator_name_, object view_component_)
Cn AppsFmMed(string mediator_name_, object view_component_, object view_form_)
//
//////////////////////////////////
// notifications come here and I respond to them
Fn HandleNotification(INotification notification_){
switch notification_.Name
case:___I_DATAPROXYNAME_DATACHANGED
}
//
//////////////////////////////////
// initialization code, wire up events
Fn hookEvents() {
assignFormEvent("FormClosed");
assignFormEvent("Load");
assignControlEvent(okBU.Name, "Click", "evtClick");
assignControlEvent(cancelBU.Name, "Click", "evtClick");
}
//
//////////////////////////////////
// utility fns
Fn initLabels()
Fn saveValues()
Fn loadValues()
Fn initForm()
//
//////////////////////////////////
// I am born and registered to recieve "interests",
Fn OnRegister()
Fn OnRemove()
//
//////////////////////////////////
// the control events are wired to these
Fn evtClick(object sender_, EventArgs e_)
Fn EvtLoad(object sender_, EventArgs e_)
Fn EvtFormClosed(object sender_, FormClosedEventArgs e_)