I controlli su un modulo dovrebbero essere preparati in una classe separata?

1

Ho un modulo con diversi controlli su di esso. Ogni controllo deve essere dichiarato nella classe, formattato nel costruttore (-size, posizione, iscrizione all'evento, ecc.) E i suoi gestori di eventi dichiarati, di nuovo, nella classe.

Questo sta diventando un po 'disorganizzato, quindi stavo pensando di rifarlo. Per ogni controllo: preparare una classe che deriva da quel tipo di controllo (che includerà localizzazione, sottoscrizione di eventi e gestori di eventi, ecc.), E quindi usarne un'istanza.

Avrò qualche problema a fare questo?

    
posta ispiro 04.12.2011 - 20:55
fonte

3 risposte

4

Se hai bisogno di avere lo stesso controllo, con la stessa formattazione, ecc. in un sacco di posti, allora questa non è una cattiva idea. Tuttavia, se ogni classe che crei venisse utilizzata solo una volta, allora non rimuoverai alcuna complessità, ma solo spostandola. Preferirei codice lineare lineare concettualmente semplice a un gruppo di classi che sono solo istanziate una volta.

    
risposta data 04.12.2011 - 22:27
fonte
0

Idealmente parlando dovresti avere una classe separata per inizializzare tutti i controlli che sono comunemente necessari nella tua applicazione. Quindi esegui l'override in base alle tue esigenze specifiche nel tuo programma principale. Questo ti renderà la vita molto più facile.

    
risposta data 04.12.2011 - 22:34
fonte
0

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_)
    
risposta data 05.12.2011 - 07:58
fonte

Leggi altre domande sui tag