Pagina 1 di 2 1 2 ultimoultimo
Visualizzazione dei risultati da 1 a 10 su 15
  1. #1

    Accesso ai controlli di un webUserControl ereditato.

    Buongiorno a tutti. Di nuovo.

    IL quesito di oggi è:

    Sto creando una soluzione che prevede l'utilizzo di web user controls. Tali user control "standard", non sono direttamente utilizzati, ma vengono ereditati da un altro usercontrol "Costumerizzato". In tal modo voglio dare un certo margine di personalizzazione dell'applicazione ad altri programmatori.

    Ho provato a personalizzare un po', ma per ora sono riuscito solamente ad aggiungere. Riesco per esempio ad aggiungere una label all'usercontrol "costumerizzato", visualizzando di conseguenza una label non esistente nell'usercontrol "standard".

    Quello che non riesco a fare è di modificare elementi definiti nell'usercontrol standard. Dall'UC costumerizzato non riesco ad accedere ai controlli (e quindi alle proprietà e ai metodi) dell'UC standard.

    Intanto vorrei sapere se è possibile farlo, e quali margini di personalizzazione ho. E poi...bè, anche come sì fa.

    Grazie a tutti.

  2. #2
    Moderatore di ASP.net L'avatar di djciko
    Registrato dal
    Nov 2002
    Messaggi
    6,887

    Re: Accesso ai controlli di un webUserControl ereditato.

    Originariamente inviato da WebMinus
    Dall'UC costumerizzato non riesco ad accedere ai controlli (e quindi alle proprietà e ai metodi) dell'UC standard.
    Come stai provando a farlo ?

  3. #3
    Utente di HTML.it L'avatar di rsdpzed
    Registrato dal
    Aug 2001
    Messaggi
    764
    L'usercontrol ha senso se è una "scatola chiusa" ovvero chi lo usa non deve poter accedere ai controlli interni.
    Se per esempio stai costruendo un usercontrol per il login non ha senso accedere alle label interne cosi:

    codice:
    Login1.LabelUsername.Text = "Username";
    ha piu senso invece scrivere:
    codice:
    Login1.UsernameText = "Username";
    In pratica l'usercontrol ti nasconde "come" è fatto internamente e ti offre un interfaccia con proprietà personalizzate.
    Internamente è molto semplice gestire la cosa, si tratta di creare una proprietà personalizzata (UsernameText) e "bindarla" alla proprietà text della label, label la cui esistenza l'utilizzatore non deve sapere nulla.

    codice:
    public string UsernameText
    {
      get
      {
        return this.LabelUsername.Text;
      }
      set
      {
        this.LabelUsername.Text = value;
      }
    }
    Questo è un meccanismo piu flessibile dell'ereditarietà ma la possibilità di usare l'ereditarietà non è esclusa. Basta dichiarare le proprietà personalizzate virtual e i controlli interni che vuoi gestire anche dalle classi derivate protected. Io però in questo frangente eviterei l'ereditarietà il piu possibile.

  4. #4
    Wow, grazie mille. Come si sarà notato sono alle prime armi con C#, e ovviamente avevo provato ad accedere ai controlli dell'user control di origine provando a richiamarli come fossero elementi del controllo costumerizzabile, senza però dichiarare l'originale come virtual.

    In realtà l'utilizzo dei server control è stato adottato non per esigenze di modularità, ma di costumerizzazione. Volevo poter permettere ad altri di modificare l'applicazione pur mantenendo un core inaccessibile, per evitare che al primo eventuale aggiornamento rilasciato tutte le modifiche apportate venissero perse. Creando un usercontrol standard e un'altro che erediti da esso, e prevedendo aggiornamenti solamente sugli UC standard, ho pensato che potesse essere la strada giusta. Grazie mille delle risposte, sono state davvero chiare e dirette.

  5. #5
    Moderatore di ASP.net L'avatar di djciko
    Registrato dal
    Nov 2002
    Messaggi
    6,887
    Visto che parli di personalizzazione, potresti partire da qui, user controls a parte:
    http://msdn.microsoft.com/en-us/magazine/cc163724.aspx

    Comunque visto che ci siamo, per i posteri, per quanto riguarda gli UC ci sono alche gli eventi, oltre alle proprietà ottimamente descritte dal preparatissimo rsdpzed.

    Domani magari ti riporto un esempio su come gestire dall'esterno dello UC lo scatenarsi di un evento accaduto al suo interno.

    Ora no perchè ho soltanto la forza di scrivere queste poche righe in italiano, senza codice. E' mezzanotte

  6. #6
    Sono finalmente riuscito a leggere il link che mi hai dato, anche se un po' velocemente. Fico! Non ho sviluppato io questa parte, ma ho dato un'occhiata, e una primordiale gestione dei profili lato programmazione è stata in effetti fatta. Ruoli e permessi devono in realtà essere coerenti con un'applicazione lato desktop con la quale la web application si interfaccia. Ma sicuramente io e google translate approfondiremo quello che ci hai indicato .

    Sono anche riuscito a mettere alla prova le dritte che mi hai dato. Utilizzando il meccanismo dell'ereditarietà, ho provato ad accedere a controlli del US standard dall'US costumerizzato. Dopo aver indicato l'using (non ho inserito riferimenti in quanto sono nello stesso progetto) ho provato a richiamare un Label.

    Questo nell'UC standard:

    codice:
    protected virtual void Page_Load(object sender, EventArg e)
    {
    ...
          Label prova = new Label();
          prova.Text = "prova";
          this.PlaceHolder1.Controls.Add(prova);
    ...
    }
    Questo nell'UC Costumerizzato:

    codice:
    ... 
    using StandardControl;
    
    namespase CostumerControl;
    {
        public partial class US_Costumer : US_Standard
       {
             protected override void Page_Load(object sender, EventArgs e)
             {
                     // Ho provato così
                     US_Standard.prova.Text = "prova2";
    
                     //Ho provato così
                     prova.Text = "prova3";
    
                     //Ho smanettato un po' come mi veniva, ma nulla
              }
       }
    }
    Ma nulla. Non riesco a modificare il Label originale.


    Poi, se posso approfitterei per farti un'altra domanda. Volendo accedere ai controlli e alle loro proprietà, in un web user control, devo per forza generare tutto in code behind all'interno del Page_Load, vero (in realtà spero di no. )? Se anche solo una label, per esempio, invece di generarla al page_load nel fine .cs la inserisco mediante tag "<asp:" , questa non sarà più accessibile e modificabile da un ipotetico user control che erediti, corretto?

    Tra poco poi, dovrò anche gestire eventi da user control diversi (tipicamente un US avrà un panel con all'interno un altro user control. Questo panel sarà nascosto e visualizzato tipo popup con un ajax control toolkit popup. La chiusura dovrebbe avvenire da bottone di un user control, la chiusura mediante bottone di altro user control). Sembra che tu mi stia leggendo nel pensiero!

  7. #7
    Originariamente inviato da WebMinus
    Volendo accedere ai controlli e alle loro proprietà, in un web user control, devo per forza generare tutto in code behind all'interno del Page_Load, vero (in realtà spero di no. )? Se anche solo una label, per esempio, invece di generarla al page_load nel fine .cs la inserisco mediante tag "<asp:" , questa non sarà più accessibile e modificabile da un ipotetico user control che erediti, corretto?
    Casomai è il contrario.
    Se crei i controlli da codice nel codebehind, stai sicuro che non ci accedi!!!
    Se invece li crei come controlli nella parte ascx, puoi raggiungerli verificando ed eventualmente modificando in public la loro dichiarazione.

    In genere comunque, quando si lavora ad oggetti (come in questo caso) le proprietà si espongono all'esterno tramite metodi di accesso come ti è già stato suggerito. Vero è anche che si risparmia un po' di tempo e di codice laciandoli accessibili senza metodi.
    Ti faccio un esempio (da codice - NON nel load - ma equivale a metterli nel ascx):
    codice:
    class controlloBase
    {
        public Label lblTesto { get; set; }
    }
    
    class myControllo : controlloBase
    {
        //myControllo eredità già lblTesto dal controlloBase
    }
    
    /******************************************/
    
    //la pagina che utilizza il controllo myControllo
    class myPage : Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            myControllo ctrl = new myControllo();
            ctrl.lblTesto.Text = "Ciao da Glauco";
        }
    }
    Nel caso tu abbia la necessità invece di nascondere l'implementazione del controllo base e permettere SOLO l'utilizzo dei dati, allora devi fare:

    codice:
    class controlloBase
    {
        protected Label lblTesto { get; set; }
    }
    
    class myControllo : controlloBase
    {
        //myControllo eredità lblTesto dal controlloBase
        //ma non è accessibile dall'esterno
        Public string Testo { 
            get
            {
                return this.lblTesto.Text;
            }
            set
            {
                this.lblTesto.Text = value;
            }
        }
    }
    
    /******************************************/
    
    //la pagina che utilizza il controllo myControllo
    class myPage : Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            myControllo ctrl = new myControllo();
            //lblTesto non è più accedibile, ma esposta tramite la proprietà Testo
            ctrl.Testo = "Ciao da Glauco";
        }
    }

  8. #8
    AAAAAHHHH!!! Non avevo capito un tubooooo!!!!

    Avevo fatto tutto tramite code behind, nel page load, convinto che fosse l'unico modo per accedere ai controlli!!! Colpa evidentemente dell'esempio che mi era stato fornito (senza una riga di commento ne nulla, mannaggia a lui!!!). Bè, poco male, sono all'inizio, e non può farmi che bene questa cosa.

    Ok, Adesso provo con l'implementazione via asp.net e ti aggiorno. Grazie mille della pazienza.

    PS: In realtà sono un po' indeciso sulla questione dei metodi per modificare i controlli. Questo è il mio ragionamento: uso i web control per poter permettere personalizzazioni del codice pur proteggendo una parte "core" di user control standard, originali, passibili di modifiche a causa di aggiornamenti del software. Creo quindi degli user control che ereditino, che possano essere modificati senza intaccare il core, e che continuino a funzionare anche dopo gli aggiornamenti.

    Secondo questo ragionamento, permettere la scrittura degli user control personalizzabili esattamente come se fossero controlli "originali" è auspicabile.

    Ma allora viene molto più naturale la sintassi da "eredita" che quella derivante da un approccio OOP.

    Questo è il ragionamento. Ha senso secondo te?

  9. #9
    Mmm... Sono confuso.

    Ho provato con l'implementazione via asp.net. Ho usato la progettazione visuale quasi sempre, tranne per alcune piccole cose, mi perdonerete.

    Tutto bene, e impostando il Page_Load dell'userControl standard come virtual, e quello Customer come override, riesco ad accedere ai controlli dell'user control standard attraverso l'intellisense. Avevo le lacrime agli occhi!.

    Poi però mi sono accorto di due cose: la prima, che se accedo, nel Page_Load dell'UC customer ai controlli standard, mi va in errore. Da cosa ho capito perchè non trova la proprietà o il controllo, perchè al Page_Load i controlli stessi non sono ancora stati generati. Come se il Page_Load avvenisse prima dell'elaborazione del codice asp.net. E' corretta la mia interpretazione? Ma in tal caso non ho idea di come fare a modificare i controlli.

    Seconda, orribile cosa: se in una pagina aspx, lato progettazione, trascino il mio UC standard, quest'ultimo si vede. Se faccio la stessa cosa con l'UC customer, non si vede nulla! Quando me ne sono accorto mi sono messo di nuovo a piangere.

    Ho provato a cercare un po' on-line, ma non ho trovato nulla di chiaro. Il mio pessimo inglese ovviamente non ha aiutato.

  10. #10
    Originariamente inviato da WebMinus

    Poi però mi sono accorto di due cose: la prima, che se accedo, nel Page_Load dell'UC customer ai controlli standard, mi va in errore. Da cosa ho capito perchè non trova la proprietà o il controllo, perchè al Page_Load i controlli stessi non sono ancora stati generati. Come se il Page_Load avvenisse prima dell'elaborazione del codice asp.net. E' corretta la mia interpretazione? Ma in tal caso non ho idea di come fare a modificare i controlli.

    mi fai vedere un po' di codice?

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2025 vBulletin Solutions, Inc. All rights reserved.