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.