Pagina personale di:
Carlo Vecchio
appunti di C#, R, SQL Server, ASP.NET, algoritmi, numeri
Vai ai contenuti

C# - Controlli Utente (User Control)

C#
Introduzione
  • In alcune situazioni i controlli forniti con l’ambiente di sviluppo non presentano le caratteristiche volute. Per esempio, una TextBox non ha una proprietà che ne cambia il colore di sfondo quando il cursore è posizionato su di essa.
  • In altre situazioni è necessario progettare dei controlli complessi, costituiti per esempio da una Label, una TextBox e una PictureBox che abbiano una qualche correlazione.
  • Queste situazioni trovano una soluzione nei "Controlli Utente" o "User Control".
  • Gli User Control consentono quindi al progettista programmatore di:
    • Riutilizzare il codice.
    • Risparmiare tempo.
    • Incapsulare il codice e facilitare il debugging.
    • Risparmiare memoria.
  • Per creare ed utilizzare uno User Control si seguono le seguenti fasi.
    • Fase 1: Progettare le caratteristiche dello User Control
    • Fase 2: Creare un Progetto Windows Form al quale aggiungere uno User Control.
    • Fase 3: Creare un Progetto Windows Form Control Library per ottenere la DLL dello User Control
    • Fase 4: Riutilizzare lo User Control.
  • Le fasi sono tutte descritte nel paragrafo successivo.

Creazione ed utilizzo di uno User Control
  • Questo articolo e il relativo esempio sono stati fatti con Visual Studio 2013 Professional in inglese. Piccole differenze sono possibili con altre versioni dell’IDE.

Fase 1: Progettare le caratteristiche dello User Control
  • Definire con precisione lo User Control che si vuole ottenere.
  • Definire l’aspetto visuale, quali e quanti Controlli standard contiene, come sono disposti i Controlli al suo interno.
  • Definire le logiche di funzionamento e le relazioni tra i Controlli al suo interno.
  • Definire le proprietà, i metodi e gli eventi che deve esporre lo User Control.

Fase 2: Creare un Progetto Windows Form al quale aggiungere uno User Control
  • In questa fase si crea un progetto standard Windows Form; poi si aggiunge uno User Control e si scrive tutto il codice dello User Control, le logiche, le proprietà e gli eventi.
  • Per fare questo, seguire i seguenti passi.
  • Creare un nuovo progetto di tipo "Windows Forms Application", assegnargli un nome a piacere, per esempio "UserControl_1". Essendo un progetto di tipo Windows Form, al momento non c’è traccia dello User Control, infatti può andare in esecuzione con F5 mostrando il form di default Form1, completamente vuoto.
  • Nel Solution Explorer, cliccare col tasto destro nel progetto, poi cliccare in "Add -> New Item…". Nella finestra che compare, selezionare "User Control", assegnare un nome alla classe (per esempio "MyUserControl") e confermare. L’IDE aggiunge la classe 'MyUserControl.cs' come si vede nella figura seguente.



  • La classe 'MyUserControl.cs' ha (come nei Form) una parte di Progettazione (o Design) e una parte di Codice, accessibili rispettivamente con Shift-F7 e con F7.
  • La parte di Progettazione è un’area di lavoro rettangolare sulla quale è possibile mettere i controlli che necessitano.
  • Ecco l’area di lavoro:



  • In questa area di lavoro vanno posizionati i Controlli (presi dal Toolbox) che servono per il progetto.
  • Per esempio, si può trascinare una Label e una TextBox all’interno del rettangolo e si può ridimensionare il rettangolo stesso ottenendo un risultato simile al seguente.



  • È già possibile fare un test dello User Control posizionandolo sul Form1, presente nel progetto.
  • Andare nel Form1 in modalità Progettazione, nel Toolbox dovrebbe essere presente lo User Control. Se non è ancora presente, occorre creare una Built (cioè compilare il progetto).
  • Ecco come appare lo User Control sul Toolbox.



  • Come tutti i controlli, anche questo può essere trascinato nel Form1 ed ha l’esatto aspetto che gli abbiamo dato nella fase di progettazione.



  • Si voglia ora esporre gli oggetti interni, cioè la 'label1' e la 'textbox1'.
  • Questa esposizione consente di accedere direttamente a tutte le proprietà, i metodi e gli eventi degli oggetti interni.
  • Per fare questo, nella classe 'MyUserControl.cs' aggiungere il seguente codice.

   public Label LblInternal
   {
       get { return label1; }
       set { LblInternal = value; }
   }

   public TextBox TxtInternal
   {
       get { return textBox1; }
       set { TxtInternal = value; }
   }

  • Adesso è possibile dal Form1 accedere agli oggetti interni, per esempio con il seguente codice si impostano le proprietà 'Text' della 'label1' e della 'textbox1'.

   private void Form1_Load(object sender, EventArgs e)
   {
       myUserControl1.LblInternal.Text = "Test";
       myUserControl1.TxtInternal.Text = "Test";
   }

  • Mandando in esecuzione il programma, il risultato è quello atteso:



  • Allo stesso modo si ha l’accesso ai metodi degli oggetti interni, per esempio il seguente codice aggiunge il testo "123" alla TextBox interna.

   myUserControl1.TxtInternal.AppendText("123");

  • Si possono definire delle altre proprietà utili al progettista per far sì – per esempio – che lo User Control abbia un comportamento differente in base al tipo.
  • Per esempio, si può definire la proprietà 'TypeControl' di tipo 'int' con il seguente codice posto nella classe 'MyUserControl.cs':

   private int _TypeControl = 0;
   public int TypeControl
   {
       get { return _TypeControl; }
       set { _TypeControl = value; }
   }

  • Una volta definita la proprietà, essa compare nel pannello 'Proprietà' del Controllo posto nel Form1.



  • Anche gli eventi dei Controlli interni possono essere esposti allo User Control.
  • Nel codice seguente da aggiungere alla classe 'MyUserControl.cs', si espone l’evento 'TextChanged' della 'textbox1'.

   public event EventHandler TextInternalChanged;
   private void textBox1_TextChanged(object sender, EventArgs e)
   {
       EventHandler handler = TextInternalChanged;
       if (handler != null)
           handler(this, EventArgs.Empty);
   }

  • A questo punto l’evento 'TextInternalChanged' compare tra gli eventi dell’oggetto posto nel Form1:



  • Facendo un doppio click sul nome dell’evento, si genera come di consueto il gestore di esso.
  • Possono essere generati anche eventi non legati a eventi dei controlli interni.
  • Per esempio, se si considera la proprietà pubblica 'TypeControl' prima definita, si può generare un evento se questa proprietà assume il valore 100.
  • Va quindi aggiunta la gestione dell’evento nella definizione della proprietà 'TypeControl'.

   private int _TypeControl = 0;
   public event EventHandler TypeControlIs100;
   public int TypeControl
   {
       get { return _TypeControl; }
       set {
           _TypeControl = value;
           if (_TypeControl == 100)
           {
               EventHandler handler = TypeControlIs100;
               if (handler != null)
                   handler(this, EventArgs.Empty);
           }
       }
   }

  • A questo punto nel progetto principale, l’oggetto 'myUserControl1' nel Form1, contiene l’evento 'TypeControlIs100' che può trattato come di consueto.
  • La fase 2 è ora completa. Si è fatto un progetto che contiene uno User Control che è stato debitamente testato nel Form1 del progetto. Allo User Control si sono aggiunti Proprietà, Metodi ed Eventi, sia appartenenti agli oggetti interni (nell’esempio una Label e una TextBox) che definiti dal progettista.

Fase 3: Creare un Progetto Windows Form Control Library per ottenere la DLL dello User Control
  • Creare un nuovo progetto di tipo "Windows Form Control Library", assegnargli un nome a piacere, per esempio "ControlLibrary_1". Se non si trova il Template, fare una ricerca nella casella di testo posta nell’angolo alto a destra della finestra "Nuovo Progetto". Essendo un progetto di tipo Control Library, non sono presenti Form. È presente lo User Control di default (chiamato 'UserControl1').
  • Dato che lo User Control è stato creato nella Fase 2, copiare dal progetto della Fase 2 al progetto corrente, i file relativi al controllo precedentemente creato. Con riferimento all’esempio descritto sopra, i file si chiamano 'MyUserControl.cs', 'MyUserControl.Designer.cs', 'MyUserControl.resx'.
  • Una volta copiati nella cartella del progetto 'ControlLibrary_1', occorre includerli in esso. Il modo più semplice consiste nel cliccare nel Solution Explorer l’icona 'Mostra tutti i file' ('Show all files'). Compare allora il controllo 'MyUserControl', fare un click destro in esso e poi cliccare in 'Include in Project'.
  • Il controllo di default 'UserControl1' invece lo si può eliminare dal progetto.
  • Nel Solution Explorer, fare un click destro sul 'ControlLibrary_1' e poi fare un click su 'Set as StartUp Project'.
  • Eseguire una compilazione del progetto e nella cartella del progetto, sottocartella 'bin\debug' è presente il file 'ControlLibrary_1.dll'.
  • La DLL creata, può essere posta in una cartella a piacere.

Fase 4: Riutilizzare lo User Control
  • Creare un nuovo progetto di tipo "Windows Forms Application", assegnargli un nome a piacere, per esempio 'ExampleMyDll'. In alternativa aprire un Progetto esistente. Essendo un progetto di tipo Windows Form, c’è di default il Form1, completamente vuoto.
  • Per poter utilizzare la DLL, nel Solution Explorer, fare un click destro in 'References' e poi in 'Add Reference…'.
  • Nella sezione 'Assemblies' cliccare sul bottone 'Browse…' e selezionare la DLL 'ControlLibrary_1.dll'. Confermare in modo da includerla nel Progetto.
  • Nella finestra 'Toolbox', fare un click destro, poi cliccare su 'Choose items…'. Nella finestra 'Choose Toolbox Items', nella scheda '.NET Framework Components', cliccare sul bottone 'Browse…' e selezionare la DLL 'ControlLibrary_1.dll'. Confermare in modo da includerla nel Toolbox.
  • Se dà l’errore 'There are no components in DLL that can be placed on toolbox', trascinare la DLL con Esplora Risorse all’interno del Toolbox.
  • A questo punto lo User Control può essere utilizzato in questo progetto.
         

© 2020 Carlo Vecchio
Torna ai contenuti