Visual Studio 2012: l’ambiente di sviluppo di casa Microsoft

Visual Studio 2012 è l’ultima versione dell’ambiente di sviluppo di Microsoft, rilasciata a settembre 2012

Gli sviluppatori che continueranno ad utilizzare versioni precedenti del sistema operativo Windows troveranno in Visual Studio 2012 nuove utili funzionalità, ma è innegabile che la vera novità dell’ambiente di sviluppo è appunto la possibilità di sviluppare applicazioni caratterizzate dall’interfaccia grafica stile Metro.

Dell’ultima versione dell’ambiente di sviluppo sono disponibili, come sempre, diverse edizioni dalla Ultimate alla Express

In particolare l’edizione gratuita Express è disponibile in diverse versioni, a seconda del target di applicazioni che si voglia sviluppare: versione per Windows Phone, versione per Windows Desktop, versione per Windows 8, ecc.

In generale, la versione più completa è la Ultimate e comunque per l’installazione di Visual Studio 2012 occorre avere installato sulla propria macchina almeno il sistema operativo Windows 7 per computer desktop e almeno Windows Server 2008 per i server. Per quanto riguarda la versione Express per Windows 8, ovviamente è necessario disporre dell’ultima versione del sistema operativo Microsoft.

Ricapitolando per le versioni Ultimate, Premium, Professional, Test Professional e per le versioni Express, tranne la versione per Windows 8, sono supportati i seguenti sistemi operativi:

• Windows 7 SP1
• Windows 8
• Windows Server 2008 R2
• Windows Server 2012

I requisiti hardware minimi sono i seguenti:

• Processore di almeno 1.6 GHz
• 1 GB of RAM
• 10 GB spazio disponibile su disco
• Disco con velocità 5400 RPM
• Scheda video compatibile con DirectX 9 e che supporti una risoluzione di risoluzione almeno 1024×768

Per gli scopi della presente guida, se non abbiamo a disposizione l’edizione Professional o Ultimate, scarichiamo ed installiamo sul nostro sistema la versione Express per Desktop. Io utilizzerò la versione Professional ma i passaggi per l’installazione sono simili per tutte le versioni.

Avviando il setup di Visual Studio 2012 ci viene per prima cosa mostrata una finestra di dialogo per la selezione del percorso di installazione e la consultazione delle informazioni sulla licenza

Accettiamo i termini della licenza selezionando il corrispondente check box e proseguiamo. Nella schermata successiva è possibile selezionare una serie di caratteristiche opzionali da installare. Selezioniamo quelle che riteniamo possano esserci utili e proseguiamo cliccando su Install

A questo punto ci viene mostrata la finestra che ci illustra i vari passaggi dell’installazione

A seconda dei componenti già installati sul computer potrebbe essere necessario riavviare più volte la macchina durante il processo di installazione. Infine, quando tutti i componenti sono stati installati correttamente, viene mostrata la finestra finale della procedura di setup che ci informa che tutto è andato a buon fine. Possiamo dunque cliccare su Launch per avviare l’ambiente di sviluppo.

Primo avvio dell’ambiente di sviluppo

Avviando Visual Studio 2012 viene mostrato lo splash screen che riepiloga le informazioni sulla versione del prodotto e sulla licenza

La prima volta che si avvia l’ambiente di sviluppo (IDE ‐ Integrated Development Environment) dopo lo splash screen viene mostrata una finestra in cui occorre selezionare le impostazioni predefinite da utilizzare per una prima configurazione dell’area di lavoro

Le differenze tra le varie impostazioni sono relative, tra le altre cose, alla posizione e visibilità delle varie finestre di lavoro, dei menù, delle barre degli strumenti e delle scorciatoie. Una cosa molto utile è che selezionando le varie opzioni sulla destra viene mostrata una descrizione delle impostazioni che verranno applicate.

Ovviamente, come vedremo, è possibile cambiare tali impostazioni quando lo desideriamo. Per gli scopi di questa guida selezioniamo l’opzione General Development Settings o Visual C# Development Settings e clicchiamo sul pulsante Start Visual Studio.

Dopo qualche secondo necessario alla configurazione siamo pronti per cominciare ad esplorare l’IDE

Prima di addentrarci nello sviluppo della nostre prime applicazioni diamo un’occhiata ai componenti dell’ambiente di sviluppo. I menù e le barre degli strumenti (Toolbar) sono posizionati nella parte superiore della finestra

Sulla sinistra e sulla destra invece sono presenti alcune delle finestre e dei pannelli disponibili

All’avvio, nella parte centrale dell’ambiente di sviluppo viene mostrata la pagina Start Page dove sulla sinistra sono presenti link, ad esempio, per la creazione di un nuovo progetto o per l’apertura di un nuovo progetto, oltre ad un elenco dei progetti recentemente aperti (Recent)

Nella parte centrale invece sono invece presenti molti utili collegamenti a varie aree formative

Quando nell’uso comune dell’IDE viene aperto un file, un form, un documento XML o altro, lo spazio centrale viene occupato dall’elemento aperto e viene creata una corrispondente tab attraverso cui è possibile spostarsi tra i vari file aperti.

Tornando alle finestre laterali, quando clicchiamo su una di queste essa viene espansa all’interno dell’area di lavoro

E’possibile spostare tali finestre in un’altra posizione dell’IDE, oppure fissarle in modo che restino sempre visibili, semplicemente agendo sugli strumenti presenti nella loro parte superiore

In generale queste finestre possono essere gestite tramite il menù View

La finestra Solution Explorer

Quando lavoriamo su un’applicazione, Visual Studio 2012 utilizza il concetto di soluzione come contenitore di tutti gli elementi appartenenti alla stessa. Una soluzione può poi essere costituita da uno o più progetti, ognuno dei quali può avere uno o più elementi associati.

La finestra Solution Explorer serve appunto a visualizzare soluzioni, progetti ed elementi ad essi associati

Nell’immagine di esempio abbiamo una soluzione denominata 'Mia Soluzione’ con annessi due progetti (Progetto1 e Progetto2), ognuno dei quali ha i propri riferimenti, proprietà e form. Ogni progetto ha associata un’icona che ne indica il tipo ed il linguaggio utilizzato (nel nostro caso C#).

Quando abbiamo più progetti all’interno di una soluzione uno di essi è in grassetto perché rappresenta il progetto di partenza (startup), cioè il progetto che viene avviato per primo quando si lancia l’applicazione. Nel caso del nostro esempio il progetto di partenza è Progetto1

Se vogliamo cambiare il progetto di startup basta cliccare con il tasto destro del mouse sul progetto da impostare come startup e selezionare dal menù contestuale l’opzione Set as StartUp Project

Nella parte superiore della finestra Solution Explorer è presente una barra degli strumenti che mette a disposizione diverse funzioni applicabili all’albero della soluzione, dalla possibilità di chiudere tutti i nodi dell’albero (Collapse All), alla visualizzazione di tutti i file della soluzione (Show All Files), al refresh degli elementi della soluzione (Refresh)

Il numero di strumenti presenti in questa barra varia a seconda del nodo selezionato. Se ad esempio selezioniamo un progetto, gli elementi disponibili sono quelli dell’immagine precedente, se invece selezioniamo un form vediamo comparire anche la funzionalità che ci permette di accedere al relativo editor di codice

Esiste anche un altro metodo per navigare attraverso i progetti ed i file di una soluzione. Se clicchiamo con il tasto destro del mouse su uno degli elementi dell’albero tra le varie opzioni del menù contestuale che si apre troviamo l’opzione Scope to This

Quando selezioniamo questa opzione il contenuto della finestra Solution Explorer cambia, ponendo il nodo selezionato al livello più alto dell’albero. Quindi nel caso del nodo Form1 abbiamo

Come possiamo notare, quando eseguiamo questa operazione viene abilitata la possibilità di navigare avanti e indietro nella finestra Solution Explorer, tramite le freccette poste in alto a sinistra. Per tornare alla vista predente in questo caso basta cliccare sulla freccia sinistra

Una delle novità più utili di Visual Studio 2012 è l’anteprima dei file contenuti nella soluzione. Tra i vari strumenti presenti nella barra della Solution Explorer troviamo infatti la voce Preview Selected Item

Quando questa opzione è impostata, se selezioniamo un file della soluzione esso viene immediatamente visualizzato in una tab apposita al centro dell’area di lavoro.

In aggiunta alle funzionalità suddette la finestra Solution Explorer mette a disposizione un menù contestuale dinamico i cui elementi variano a seconda dell’elemento selezionato. Ad esempio il menù contestuale di un nodo soluzione è il seguente

Mentre il menù contestuale di un progetto è il seguente

E’ evidente che il numero ed il tipo di alcune delle opzioni presenti è diverso e nel corso della guida avremo modo di evidenziare le funzionalità di molte di esse.

La finestra Toolbox

Uno dei maggiori vantaggi di Visual Studio rispetto agli altri ambienti di sviluppo è sempre stata la possibilità di utilizzare il drag and drop degli elementi di un’applicazione da una finestra denominata Toolbox alla finestra di progettazione grafica.

Il Toolbox può essere visualizzato tramite il menù View cliccando sulla voce corrispondente

La finestra Toolbox contiene tutti gli elementi disponibili per il documento correntemente visualizzato nello spazio di lavoro principale (workspace), dai componenti visuali (textbox, button, ecc.), ai componenti invisibili graficamente che forniscono determinati servizi (timer, event log, ecc.) passando per altri elementi di progettazione.

Ad esempio per un progetto Windows Form il Toolbox ci apparirà nel modo seguente

Come possiamo vedere, in Visual Studio 2012 i componenti disponibili sono suddivisi in gruppi, in modo da rendere più semplice l’individuazione dei controlli che di volta in volta ci servono. Ad esempio, i componenti di tipo contenitore sono inseriti nel gruppo Containers

Come impostazione predefinita i gruppi sono presentati in modalità lista e ogni componente è rappresentato dalla propria icona e dal nome, tuttavia se clicchiamo con il tasto destro del mouse su un gruppo e deselezioniamo l’opzione List View gli elementi di quel gruppo verranno visualizzati solo tramite le proprie icone. Il gruppo Containers che abbiamo appena visto comparirà nel modo seguente

Per quanto riguarda il modo in cui i componenti possono essere inseriti all’interno di una nostra applicazione basta semplicemente trascinarli sulla superficie di progettazione del documento corrente (ad esempio un form) oppure fare doppio click sul componente stesso.

I componenti visuali, come i controlli textbox e radiobutton, appaiono direttamente nell’area di progettazione dove possono essere spostati, ridimensionati e via dicendo, mentre gli elementi non visuali, come il controllo timer, appaiono in un’area posta al di sotto di quella di progettazione

Avere gli elementi del Toolbox ordinati alfabeticamente è una buona scelta ma se solitamente utilizziamo un numero ristretto di essi potrebbe essere più conveniente creare un proprio gruppo all’interno del Toolbox in cui posizionare gli elementi che vogliamo. Per fare questo basta cliccare all’interno del Toolbox con il tasto destro del mouse e selezionare nel menù contestuale la voce Add Tab. In questo modo viene inserito un nuovo gruppo che possiamo chiamare come vogliamo e a questo punto possiamo trascinare al suo interno tutti gli elementi che desideriamo.

Ogni elemento può essere spostato dal gruppo originario al nuovo gruppo oppure può copiato dal gruppo originario al nuovo gruppo. La differenza è che nel secondo caso l’elemento di troverà sia nel gruppo originario sia nel nuovo gruppo. Per copiare un elemento basta tenere premuto il tasto Ctrl durante lo spostamento dello stesso.

Tramite il menù contestuale (tasto destro del mouse) è possibile effettuare all’interno del Toolbox varie utili operazioni, come ordinare gli elementi alfabeticamente, rinominare gli elementi o resettare le impostazioni a quelle di partenza

Una funzionalità molto utile è la possibilità di effettuare ricerche all’interno del Toolbox. In alto infatti è presente una finestra di ricerca e se, per esempio, scriviamo text ci compariranno tutti gli elementi il cui nome contiene questa stringa

A volte può capitare che un particolare componente non sia presente nella lista del Toolbox. Per aggiungerlo basta cliccare con il tasto destro del mouse sul gruppo in cui si vuole inserire e selezionare nel menù contestuale Choose Items. Dopo qualche secondo ci viene mostrata una lista di componenti del .NET Framework

A questo punto basta selezionare gli elementi da aggiungere (o deselezionare quelli da togliere) e cliccare su OK. Se non riusciste ad individuare subito l’elemento che cercate potete utilizzare il campo Filter per cercarlo.

Oltre a componenti del .NET Framework è possibile aggiungere componenti COM, WPF, Silverlight, semplicemente selezionando la corrispondente tab. Inoltre, se il componente non compare è possibile utilizzare il pulsante Browse per individuare il suo file fisico sul computer.

La finestra delle proprietà

Una delle finestre più utilizzate in Visual Studio è la finestra delle proprietà (Properties), costituita da una griglia di proprietà relative all’elemento correntemente selezionato nella finestra Solution Explorer o all’elemento selezionato nell’area di progettazione di un form. Se ad esempio selezioniamo il form del nostro progetto di prova, clicchiamo con il tasto destro del mouse su di esso e selezioniamo la voce Properties dal menù contestuale ci apparirà la finestra delle proprietà del form

Ogni linea di questa finestra corrisponde ad una proprietà, con un nome sulla prima colonna ed il corrispondente valore nella seconda colonna. E’ possibile raggruppare le proprietà o visualizzarle in ordine alfabetico agendo rispettivamente sulla prima e seconda delle icone poste nella parte superiore della finestra

Quando selezioniamo una proprietà il suo nome viene evidenziato e nella parte inferiore della finestra viene mostrata una descrizione della stessa

Nell’immagine precedente possiamo notare che il testo Form1 è in grassetto e questo succede quando il valore di una proprietà è diverso da quello predefinito. Se andiamo a guardare il codice che Visual Studio genera automaticamente in corrispondenza delle modifiche visuali che apportiamo nella finestra di progettazione, notiamo che esiste una linea di codice per ogni proprietà che è evidenziata in grassetto nella finestra delle proprietà

// 
// Form1
// 
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.ClientSize = new System.Drawing.Size(292, 273);
this.Controls.Add(this.radioButton1);
this.Name = "Form1";
this.Text = "Form1";
this.ResumeLayout(false);
this.PerformLayout();

Le proprietà in sola lettura sono colorate in grigio ed i corrispondenti valori non possono essere modificati.

Oltre a visualizzare le proprietà dell’elemento selezionato, la finestra delle proprietà consente di generare i gestori di eventi (event handlers) per lo stesso. Per visualizzare tutti gli eventi associati ad un determinato componente basta cliccare sull’icona del fulmine posta in alto. Per il form appena visto la lista degli eventi è la seguente

Anche in questo caso, selezionando l’evento viene mostrata in basso una descrizione delle sue caratteristiche.

Per generare un nuovo gestore di evento basta posizionarsi sull’evento che ci interessa e fare doppio click sulla seconda colonna dello stesso. In questo modo viene automaticamente generato il nome dell’evento

Inoltre viene inserito il codice corrispondente nel file .cs

Certi componenti, come il controllo DataGridView, espongono un certo numero di comandi, o scorciatoie, che possono essere eseguiti tramite la finestra delle proprietà. Nel caso della DataGridView possiamo vedere i due comandi Edit Columns e Add Columns

Se clicchiamo su questi link viene mostrata una finestra di dialogo per effettuare l’operazione indicata. Se i comandi non sono immediatamente visibili cliccate con il tasto destro del mouse all’interno della finestra delle proprietà e selezionate nel menù contestuale la voce Commands

Tramite la voce Description si può impostare anche la visualizzazione o meno delle descrizioni delle proprietà e degli eventi.

Personalizzazione dell’area di lavoro

Dopo aver acquistato familiarità con le impostazioni generali di Visual Studio 2012 è giunto il momento di imparare come personalizzare l’ambiente di sviluppo, per favorire il nostro stile di lavoro.

Cominciamo con la pagina iniziale (Start Page) che compare come impostazione predefinita all’avvio di Visual Studio. E’ possibile modificare questa impostazione dal nodo Startup della finestra di dialogo che si apre se clicchiamo nel menù Tools sulla voce Options

Nel campo At startup si possono selezionare opzioni alternative all’apertura della pagina iniziale

Il motivo per cui solitamente i programmatori utilizzano la pagina iniziale è che essa fornisce un utile punto di partenza dal quale poter effettuare diverse azioni

A sinistra sono presenti alcuni link per la connessione a Team Foundation Server e per la creazione o l’apertura di progetti. E’ presente anche una lista dei progetti recentemente aperti.

In basso a sinistra sono presenti due checkbox che permettono di stabilire se la pagina iniziale debba essere chiusa dopo il caricamento di un progetto e se la stessa debba essere visualizzata all’avvio di Visual Studio

Se non si conosce bene l’ambiente di sviluppo il comportamento di numerose finestre e barre degli strumenti (toolbar) può risultare poco intuitivo, perché sembra che esse compaiano in posizioni casuali e scompaiano quando si passa dalla scrittura del codice all’esecuzione dello stesso. In realtà, come vedremo tra poco, ogni elemento ha una sua precisa funzionalità.

Se all’interno del nostro progetto apriamo più file contenuti all’interno della finestra Solution Explorer notiamo che il numero delle toolbar nella parte alta dello schermo varia a seconda del tipo di file correntemente aperto. Ogni toolbar (e ogni pulsante ad essa associato) ha infatti un’associazione predefinita a specifiche estensioni di file, in modo che Visual Studio sappia quali di esse far visualizzare quando file con tali estensioni vengono aperti.

Quando una finestra di strumenti o una toolbar vengono chiuse, può essere difficoltoso individuarle nuovamente. Fortunatamente la maggior parte di quelle usate più frequentemente possono essere visualizzate di nuovo tramite il menù View

Altre finestre, prevalentemente mirate al debugging, sono accessibili invece tramite il menù Debug

Tutte le toolbar disponibili in Visual Studio 2012 sono invece elencate e accessibili tramite il menù View selezionando la voce Toolbars

E’ possibile accedere alla lista delle toolbar anche cliccando con il tasto destro del mouse in un punto qualsiasi dell’area delle toolbar. In ogni caso, quando una toolbar è visibile è possibile impostare quali pulsanti della stessa debbano essere visualizzati, tramite l’opzione Customize presente nella parte inferiore dell’elenco delle toolbar. Alternativamente è possibile cliccare sulla freccia posta a destra di una toolbar e selezionare i pulsanti da visualizzare

Ogni finestra degli strumenti ha una posizione predefinita che assume nel momento in cui la apriamo tramite il menù View. Per esempio, quando apriamo il Toolbox esso viene posizionato nella parte sinistra dell’ambiente di sviluppo.

Quando una finestra viene aperta e posizionata in uno dei lati dell’IDE essa può assumere due stati, bloccata (pinned) o sbloccata (unpinned). Nel primo caso la finestra è sempre visibile, nel secondo la finestra scompare di lato quando non è più attiva e dobbiamo cliccare sulla sua etichetta per visualizzarla di nuovo

Per cambiare lo stato di una finestra basta impostare verticalmente (bloccata) o orizzontalmente (sbloccata) il pin posto alla sua sommità

La posizione di ogni finestra la possiamo scegliere noi semplicemente cliccando sulla barra del titolo in alto dove è visualizzato il suo nome e trascinandola, tenendo premuto il pulsante sinistro del mouse

In questa fase ci vengono mostrati tutti i punti in cui è possibile fissare la finestra e quando ci avviciniamo ad uno dei punti viene mostrata un’area blu corrispondente all’area che verrà eventualmente occupata dalla finestra.

E’ anche possibile posizionare una finestra all’interno di un’altra o meglio suddividere la vista in due finestre, semplicemente trascinando una finestra all’interno di un’altra

L’ultima cosa relativa alle finestre è che è possibile non fissarle selezionando l’opzione Float dal menù che compare cliccando sulla freccia presente nella barra del titolo

In base a quanto visto ognuno di noi può impostare l’area di lavoro nel modo a lui più consono.

L’editor di codice

Chi utilizza Visual Studio solitamente spende una considerevole porzione del suo tempo a scrivere codice. Per supportare e facilitare tale attività, l’editor di codice (code editor, sviluppato in tecnologia WPF) presente all’interno dell’IDE fornisce numerose funzionalità.

Quando clicchiamo su un file all’interno della finestra Solution Explorer esso viene aperto nella finestra editor di codice, la cui parte principale è ovviamente il pannello in cui viene visualizzato il codice sorgente

Sopra al pannello contenente il codice sono posizionati due menù a tendina che possono aiutare nella navigazione all’interno del codice. Il primo menù mostra la lista delle classi presenti nel file attuale, il secondo la lista dei membri della classe attualmente selezionata

In alcuni casi i file di codice possono contenere molti elementi e per ordinare tutti questi elementi esistono due possibilità. Una è quella di creare le cosiddette classi parziali (partial classes), ovvero suddividere una classe in più file fisici che rappresentano logicamente una stessa classe. Per fare ciò basta semplicemente che in ogni file la definizione della classe sia la medesima e contenga la parola riservata partial

Il vantaggio di questo approccio è che effettivamente è possibile raggruppare elementi correlati, lo svantaggio è che la navigazione all’interno del codice richiede il continuo passaggio da un file all’altro.

Un’altra possibilità è quella di creare, all’interno di uno stesso file fisico, regioni per raggruppare porzioni di codice correlate. Se, ad esempio, vogliamo creare una regione contenente tutti i gestori di eventi di una classe possiamo procedere utilizzando le direttive #region e #endregion

Una volta creata la regione possiamo cliccare sul segno meno o sul segno più posto sulla prima linea rispettivamente per comprimerla o espanderla

Vi faccio notare che oltre alle regioni diversi altri elementi all’interno dell’editor di codice possono essere compressi ed espansi (classi, metodi, ecc.).

Una caratteristica molto utile in Visual Studio è che quando ci muoviamo all’interno del codice il sistema tiene traccia di tutti i nostri spostamenti, un pò come un browser web tiene traccia dei siti che si visitano. Possiamo sfruttare questa cosa utilizzando le funzionalità Navigate Forward e Navigate Backward contenute nel menù View

L’editor di codice mette a disposizione tantissime funzionalità che non possiamo analizzare una per una, tuttavia dobbiamo citare almeno alcune di esse. La prima è l’evidenziazione dei riferimenti (reference highlighting) che consiste nel fatto che se evidenziamo uno specifico elemento di codice (nel caso dell’esempio seguente dip), tutte le ricorrenze di quel codice vengono evidenziate

Un’altra utile funzionalità è la possibilità di effettuare lo zoom sul nostro codice. Per fare questo basta tenere premuto il tasto Ctrl e agire sulla rotella del mouse, oppure variare la percentuale di zoom nel campo in basso a sinistra dell’editor.

In alcuni casi potremmo avere l’esigenza di visualizzare contemporaneamente porzioni differenti dello stesso file di codice. Per fare questo possiamo ricorrere alla cosiddetta split view, che ci consente di suddividere l’editor in due pannelli, separati da una barra a scorrimento (splitter bar). Per effettuare questa operazione basta selezionare l’opzione Split nel menù Window ed il risultato sarà simile al seguente

A volte si presenta l’esigenza di commentare o decommentare un blocco intero di codice ed in tali casi risulta fastidioso aggiungere o rimuovere i caratteri per commentare ogni singola linea del blocco. Visual Studio fornisce un metodo per effettuare questo tipo di operazione selezionando il blocco da commentare e poi cliccando sulla voce Comment Selection o Uncomment Selection dell’opzione Advanced del menù Edit oppure utilizzando le scorciatoie da tastiera Ctrl+K+C e Ctrl+K+U rispettivamente.

Altre volte si presenta l’esigenza di selezionare una parte di un blocco di testo invece della normale funzionalità di selezione del blocco da un’estremità all’altra. In questi casi ci viene in aiuto la cosiddetta block selection. Per selezionare una porzione di un blocco di testo basta tenere premuto il pulsante Ctrl e selezionare con il mouse solo la porzione in desiderata

Infine le ultime due funzionalità su cui ci soffermiamo sono Go to Definition e Find All References. La prima serve a individuare la definizione di una classe, un metodo o un membro e si utilizza semplicemente cliccando con il tasto destro del mouse sul nome dell’elemento da ricercare e selezionando la corrispondente opzione. La seconda funzionalità si applica allo stesso modo ma il risultato è la visualizzazione della finestra Find Symbol Result, in cui sono elencati tutti i punti del codice in cui è presente l’elemento ricercato

Facendo doppio click su una linea accediamo alla porzione di codice corrispondente.

Altre utili finestre

All’interno dell’IDE di Visual Studio sono disponibili tante altre utili finestre e nella presente lezione ne vedremo alcune.

Immediate Window

Spesso quando si scrive il codice di un’applicazione si ha l’esigenza di valutare semplici espressioni. Questi sono i casi in cui è molto utile la finestra Immediate (Immediate Window), poiché essa consente di eseguire espressioni semplicemente digitandole al suo interno

Quando digitiamo un comando in questa finestra in modalità progettazione, Visual Studio compila la soluzione prima di eseguire lo stesso. Se la compilazione non va a buon fine l’espressione non può essere valutata, finchè non vengono risolti gli errori di compilazione.

Per visualizzare la finestra Immediate basta selezionare la corrispondente opzione nella voce Windows del menù Debug.

Class View

Sebbene la finestra Solution Explorer sia probabilmente lo strumento migliore per navigare all’interno delle nostre soluzioni, a volte può risultare difficile individuare classi e metodi particolari. La vista Class (Class View) è una finestra che fornisce una vista alternativa delle soluzioni elencando i namespace, le classi ed i metodi in modo da poter facilmente navigare tra di essi.

Considerando una semplice applicazione di prova contenente pochi elementi, ecco come ci appare la Class view (sotto la finestra Solution Explorer)

Per visualizzare questa vista basta selezionare la corrispondente voce nel menù View.

Error List

La finestra Error List mostra gli errori di compilazione, gli avvisi (warning) ed i messaggi relativi ad una soluzione

La finestra si visualizza selezionando la corrispondente voce nel menù View e gli errori compaiono nella lista quando si modifica il codice e quando si compila il progetto. Facendo doppio click su un errore viene aperto il file corrispondente ed il cursore viene posizionato sulla linea di codice interessata. E’ anche possibile filtrare la lista visualizzata agendo sui pulsanti Errors, Warnings e Messages presenti nella parte superiore della finestra.

Object Browser

Un altro modo di visualizzare le classi contenute nelle nostre applicazioni è attraverso la finestra Object Browser. Come impostazione predefinita tale finestra appare non fissata ad uno dei lati dell’IDE ma nello spazio dell’editor. Per visualizzare questa finestra basta cliccare sulla voce Object Browser del menù View

Come si può notare nella parte alta della finestra è presente un menù a tendina (Browse) che permette di stabilire l’area degli oggetti da visualizzare.

Nella parte centrale della finestra possiamo vedere la lista dei membri della classe selezionata (Form1) e in basso la definizione completa della classe stessa.

Code Definition Window

Quando navighiamo all’interno del nostro codice capita di imbattersi in una chiamata di un metodo di cui si vorrebbe conoscere i dettagli, ma senza abbandonare la posizione corrente nell’editor di codice. In questi casi uno strumento molto utile è la finestra di definizione del codice (Code Definition Windows) che si può visualizzare cliccando sull’opzione Code Definition Window del menù View

Nell’immagine precedente ho selezionato nell’editor di codice la chiamata al metodo InitializeComponent e come si può vedere nella finestra Code Definition viene mostrata l’intera implementazione del metodo.

Si tratta di una finestra simile a quella dell’editor di codice, ma è in sola lettura. Per modificare il codice al suo interno basta cliccare con il tasto destro del mouse in un suo qualsiasi punto e selezionare l’opzione Edit Definition. Il risultato sarà l’apertura del file contenente il codice sorgente da modificare in una finestra dell’editor di codice.

Call Hierarchy Window

La finestra Call Hierarchy mostra tutte le chiamate verso o da un metodo, consentendo dunque di vedere quando un metodo viene utilizzato ed inoltre quali chiamate esso effettua verso altri metodi. In questo modo possiamo facilmente seguire l’esecuzione ed il flusso del nostro codice.

Per visualizzare la finestra Call Hierarchy per un determinato metodo basta selezionare il metodo nell’editor di codice, cliccare con il tasto destro del mouse sullo stesso e selezionare l’opzione Call Hierarchy Window dal menù contestuale che appare. Questa operazione mostra il metodo in oggetto in un albero con tre nodi figli: Calls To(nome_metodo), Calls From(nome_metodo) e Override

La lista Calls To mostra tutti i metodi che chiamano il metodo in oggetto, la lista Calls From mostra tutti i metodi che sono chiamati dal metodo in oggetto. Inoltre per i membri virtuali o astratti compare un ulteriore nodo denominato Overrides. Facendo doppio click su uno dei metodi mostrati viene aperto il corrispondente file di codice nell’editor di codice.

Ovviamente quelle viste sono solo alcune delle finestre e funzionalità disponibili in Visual Studio 2012. Per approfondire la conoscenza di quelle che non abbiamo analizzato vi invito a consultare la documentazione ufficiale Microsoft.

Funzionalità trova-sostituisci e guida

Una delle caratteristiche che contraddistinguono un buon programmatore è la capacità di navigare facilmente all’interno del codice sorgente e di trovare rapidamente quello che si cerca. Visual Studio 2012 mette a disposizione un certo numero di funzioni di ricerca, ognuna con un particolare obiettivo.

Il metodo più semplice di effettuare ricerche in Visual Studio 2012 è quello di utilizzare la finestra di dialogo Quick Find. Questa finestra consente di ricercare una parola o una frase all’interno del documento corrente oppure in altri ambiti, come vedremo.

Per aprire questa finestra di dialogo possiamo utilizzare la combinazione di tasti Ctrl+F oppure possiamo selezionare Quick Find nell’opzione Find and Replace del menù Edit. Visual studio mostra all’apertura la finestra di base con l’azione Find selezionata

Per chi ne abbia avuto esperienza, rispetto alle versioni precedenti di Visual Studio la finestra dal punto vista del layout è cambiata significativamente, tuttavia il meccanismo che effettua le ricerche è rimasto invariato. Basta scrivere la parola da ricercare nella casella o selezionarla dalle ricerche precedenti cliccando sulla freccia del menù a tendina. Come impostazione predefinita, l’area di ricerca è limitata al documento corrente, a meno che non siano state selezionate un certo numero di linee di codice, nel cui caso l’area di ricerca diventa la selezione stessa.

Ovviamente è possibile cambiare l’area di ricerca, selezionando anche l’intero progetto o l’intera soluzione

Cliccando sulla freccia rivolta verso il basso accanto alla casella di testo Find si passa alla modalità Replace

La funzionalità di find and replace (trova e sostituisci) opera sempre sull’area selezionata per la ricerca e si ferma soltanto quando raggiunge nuovamente il punto di partenza.

A volte si può presentare l’esigenza di specificare alcuni criteri e filtrare i risultati della ricerca in diversi modi. Nella parte inferiore della finestra possiamo notare la presenza di tre pulsanti: il primo consente di impostare se la ricerca debba essere case sensitive o meno; il secondo se la ricerca debba essere effettuata sulla corrispondenza esatta della parola ricercata o anche su una sua parte; il terzo permette di impostare una ricerca basata sulle cosiddette espressioni regolari (regular expressions).

A destra della casella di testo Replace possiamo notare la presenza di altri due pulsanti: il primo serve a sostituire solo la prima occorrenza della ricerca; il secondo serve a sostituire tutte le occorrenze della ricerca che viene effettuata.

Quando apriamo il menù a tendina contenente le ricerche recenti possiamo notare la presenza dell’opzione Find In Files

Cliccando su questa opzione ci viene mostrata una finestra di dialogo molto simile a quella che nelle precedenti versioni di Visual Studio era la finestra Quick Find

Questa finestra rappresenta la parte più potente del motore di ricerca di Visual Studio 2012. Essa infatti invece di restringere la ricerca al massimo fino ai file della soluzione corrente (come fa la Quick Find) permette di effettuare la ricerca all’interno di cartelle e sottocartelle individuando i file che contengono i criteri di ricerca.

Oltre che dalla finestra Quick Find, la finestra Find and Replace in Files può essere aperta cliccando sulla voce Find and Replace del menù Edit.

In questa finestra sono disponibili le stesse opzioni di ricerca della finestra Quick Find ma a destra del campo Look in è presente un pulsante ellipsis cliccando il quale si apre un’altra finestra di dialogo in cui è possibile selezionare la cartella all’interno della quale deve essere effettuata la ricerca

Un’altra caratteristica di questa finestra da segnalare è la presenza del campo Look at these file types, che permette di selezionare l’estensione dei file su cui effettuare la ricerca.

E’ anche possibile impostare le opzioni di visualizzazione dei risultati

Per passare alla modalità Replace basta cliccare sulla corrispondente label posta nella parte superiore della finestra.

Quando effettuiamo una ricerca all’interno dei file i risultati vengono mostrati in una di due finestre disponibili (Find Results)

Per quanto riguarda le funzionalità di ricerca, mi voglio infine soffermare sulla funzionalità Navigate To, uno strumento di ricerca che rappresenta un’alternativa alle funzioni di ricerca che abbiamo appena visto. A differenza di quanto visto precedentemente questa finestra consente soltanto la ricerca tramite parole ed elenca i risultati in una lista sottostante al campo di ricerca

Facendo doppio click su un elemento della lista viene aperto il corrispondente file nell’editor. Per visualizzare questa finestra basta cliccare sulla voce Navigate To del menù Edit.

Infine per concludere la presente lezione voglio soffermarmi sulla guida di Visual Studio (Help). I moderni programmatori sono a contatto con una grande varietà di tecnologie in continua evoluzione e stare al passo con le stesse non è impresa semplice. Spesso sapere come trovare informazioni su tali tecnologie è un’importante risorsa ed il sistema di help di Visual Studio fornisce proprio questo tipo di supporto ai programmatori.

Il modo più semplice per ottenere informazioni è quello di premere il tasto di aiuto per antonomasia di ogni applicazione Microsoft, cioè il tasto F1. Il sistema di supporto di Visual Studio 2012 si basa su Microsoft Help Viewer 2 e invece di utilizzare una finestra ad hoc per visualizzare le informazioni, apre una finestra del browser web

Il sistema di supporto è contestuale e questo significa che se il cursore è posizionato su una determinata classe .NET del nostro progetto e clicchiamo su F1 la finestra di supporto viene immediatamente aperta su un tutorial relativo a questa classe.

In altre situazioni possiamo avere l’esigenza di accedere all’intera lista di contenuti presente sul sistema di supporto e per fare ciò basta utilizzare il menù HELP

Struttura e proprietà di una soluzione

Le applicazioni più complesse richiedono più di un file sorgente e questo comporta una serie di problematiche tra cui il nome da dare ai file, la collocazione e la riusabilità dei file stessi. All’interno di Visual Studio 2012 esiste, come abbiamo già accennato, il contenitore soluzione che può contenere una serie di progetti, ognuno dei quali a sua volta è costituito da un insieme di elementi. Questo aiuta non poco i programmatori a gestire i propri file di codice.

Il modo migliore di strutturare le applicazioni sviluppate in Visual Studio è quello di avere una singola soluzione contenente uno o più progetti. Ogni progetto a sua volta può essere costituito da un insieme di file di codice e cartelle di lavoro. La finestra in cui viene visualizzata l’intera soluzione è la Solution Explorer, che abbiamo già avuto modo di vedere nella prima parte della presente guida

Visual Studio 2012 per ogni soluzione crea due file con estensioni .suo e .sln (solution file). Il primo è un file binario difficile da editare che contiene informazioni specifiche sull’utente, per esempio quali file erano in uso quando la soluzione è stata aperta l’ultima volta oppure la posizione dei breakpoint. Si tratta di un file nascosto, quindi normalmente non viene visualizzato nella cartella della soluzione, a meno che non sia abilitata la visualizzazione dei file nascosti. L’altro file contiene invece informazioni sulla soluzione, come la lista delle proprietà, le configurazioni di compilazione e altre informazioni che non sono specifiche per i progetti.

Diversamente da tanti altri file all’interno di Visual Studio 2012, il file relativo alla soluzione non è in formato XML ma è costituito da blocchi di testo. Ecco un esempio del contenuto di tale file

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2012
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = 
"Progetto1", "WindowsFormsApplication2Progetto1.csproj", 
"{800FB26E-8D7C-49FE-903D-B3938F71EE20}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Release|Any CPU = Release|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{800FB26E-8D7C-49FE-903D-B3938F71EE20}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{800FB26E-8D7C-49FE-903D-B3938F71EE20}.Debug|Any CPU.Build.0 = Debug|Any CPU
{800FB26E-8D7C-49FE-903D-B3938F71EE20}.Release|Any CPU.ActiveCfg = Release|Any CPU
{800FB26E-8D7C-49FE-903D-B3938F71EE20}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal

In questo caso la soluzione è costituita da un singolo progetto, denominato Progetto1, e una sezione Global contiene le impostazioni da applicare a tutta la soluzione.

Per visualizzare le proprietà di una soluzione basta cliccare con il tasto destro del mouse sul nodo della soluzione e selezionare nel menù contestuale che compare la voce Properties. Ci comparirà la seguente finestra di dialogo

In tale finestra sono presenti due nodi per le proprietà, Common e Configuration.

Common Properties

La prima proprietà di questa sezione è Startup Project, per la quale sono disponibili tre opzioni: l’opzione Current selection determina l’avvio del progetto correntemente selezionato nella finestra Solution Explorer; l’opzione Single startup project permette di impostare il progetto da avviare ogni volta che si esegue l’applicazione; l’opzione Multiple startup projects consente di impostare l’avvio di più progetti in uno specifico ordine. Quest’ultima opzione può essere utile quando, ad esempio, si ha un’applicazione con sezioni clientserver all’interno di una stessa soluzione e si vogliono avviare entrambe.

La sezione Projects Dependencies è utilizzata per indicare altri progetti da cui un determinato progetto dipende

Il contenuto delle dipendenze (Depends on) è determinato dai riferimenti che inseriamo all’interno dei nostri progetti.

La sezione Code Analysis Settings è disponibile solo nelle versioni Premium e Ultimate di Visual Studio 2012 e consente di selezionare la tipologia di analisi del codice per ogni progetto.

La sezione Debug Source File serve a specificare una lista di cartelle in cui Visual Studio può ricercare file sorgenti

Configuration Properties

Sia i progetti che le soluzioni hanno associati configurazioni di compilazione che determinano quali elementi debbano essere compilati e in che modo. Questo può provocare un po’ di confusione perché non c’è una correlazione tra la configurazione di un progetto, che determina come i vari elementi debbano essere compilati, e la configurazione di una soluzione, che determina quali progetti debbano essere compilati. Una soluzione mette a disposizione le configurazioni Debug e Release, che corrispondono alla compilazione di tutti i progetti contenuti nella soluzione in una di queste due modalità.

Quando selezioniamo il nodo Configuration Properties vengono abilitati in alto i menù a tendina Configuration e Platform

Il campo Configuration contiene tutte le possibili configurazioni per la soluzione

Il campo Platform contiene tutte le piattaforme disponibili

Nella griglia è possibile impostare la configurazione e la piattaforma per ogni progetto contenuto nella soluzione.

Tipi di progetto e proprietà

In Visual Studio 2012 i progetti sono suddivisi per linguaggio, quindi nel momento in cui vogliamo crearne uno nuovo dobbiamo selezionare la giusta tipologia nella finestra New Project

Con l’eccezione dei progetti di tipo Web Site, ogni progetto contiene un file di progetto (con estensione .csproj ad esempio per progetti in linguaggio C#). Quando selezioniamo un modello (template) di progetto e confermiamo viene creato un nuovo progetto popolato con le impostazioni e le classi predefinite.

Le categorie di progetti più rilevanti in Visual Studio 2012 sono:

Windows ‐ Questa categoria include la maggior parte dei progetti più comunemente utilizzati tra cui applicazioni Windows Form, applicazioni Console, applicazioni WPF

Questi tipi di progetti generano file eseguibili (.exe) utilizzabili direttamente dall’utente finale. Questa categoria include anche però alcuni tipi di progetto di librerie, come Class Library, che una volta creati possono essere referenziati da altri progetti. I progetti di tipo libreria di classi hanno estensione .dll.

Web ‐ Questa categoria include i tipi di progetto che girano sotto ASP.NET tra cui applicazioni web (incluso MVC), servizi web XML, librerie di controlli da utilizzare in applicazioni web

Office ‐ Questa categoria consente di integrare le applicazioni Office con funzionalità aggiuntive.

Cloud ‐ Questa categoria contiene solo un link attraverso cui scaricare il Windows Azure SDK.

Dopo aver effettuato l’installazione del SDK, in questa sezione compariranno i tipi di progetto correlati allo sviluppo di applicazioni Azure.

Reporting ‐ Questa categoria contiene il tipo di progetto Reports Application, ideale per generare velocemente report complessi a partire da una sorgente dati.

Silverlight ‐ Questa categoria contiene i tipi di progetto per la creazione di applicazioni Silverlight.

Test ‐ Questa categoria contiene il tipo di progetto Unit Test che è possibile utilizzare per effettuare test su altri progetti.

WCF ‐ Questa categoria contiene tipi di progetto per creare applicazioni che forniscono servizi WCF.

SQL Server ‐ Questa categoria contiene il tipo di progetto SQL Server Database per generare codice da utilizzare all’interno di SQL Server.

Per approfondire la conoscenza dei suddetti tipi di progetto e per gli altri tipi di progetto vi invito a consultare la documentazione ufficiale Microsoft.

La finestra di dialogo New Project consente di creare il tipo di progetto che vogliamo e in essa è possibile selezionare la versione del .NET Framework da utilizzare

Se un determinato tipo di progetto non è supportato dalla versione correntemente selezionata del .NET Framework esso non compare in elenco.

Dopo aver creato un progetto, per accedere alle sue proprietà basta cliccare con il tasto destro del mouse sul nodo corrispondente della finestra Solution Explorer e selezionare nel menù contestuale la voce Properties. A differenza delle proprietà di una soluzione, le proprietà di un progetto non compaiono in una finestra modale ma come una tab all’interno dell’editor di Visual Studio 2012

L’editor delle proprietà del progetto contiene una serie di tab verticali che raggruppano le varie proprietà e adesso analizzeremo quelle più importanti.

Application

La prima tab è denominata Application e consente al programmatore di impostare le informazioni relative al file (assembly) che viene generato quando si effettua la compilazione del progetto. Tra i vari attributi che è possibile impostare c’è il tipo di output (Output Type), che indica il tipo di file che verrà generato dopo la compilazione (Windows o Console Application, Class Library, Windows Service, ecc.), l’icona dell’applicazione, l’oggetto da avviare (Startup object), la versione del .NET Framework da utilizzare.

Cliccando sul pulsante Assembly Information viene aperta la finestra di dialogo Assembly Information in cui è possibile impostare le informazioni che verranno visualizzate dopo l’installazione dell’applicazione e quando le proprietà del file saranno visualizzate in Windows Explorer

Ogni proprietà di tale finestra è correlata ad un attributo applicato all’assembly, quindi anche all’interno del codice è possibile recuperare ed utilizzare tali informazioni.

Compilando il nostro progetto, cliccando con il tasto destro del mouse sul file generato e aprendo la finestra delle proprietà, nella tab Dettagli vedremo le informazioni impostate nella finestra Assembly Information

A proposito dei file assembly, Visual Studio 2012 fornisce un supporto per lo sviluppo di applicazioni compatibili con il controllo dell’account utente (User Account Control – UAC) di Windows Vista, Windows 7 e Windows 8. Questo implica la generazione di un file manifest, cioè un file XML che notifichi al sistema operativo se un’applicazione richieda o meno privilegi amministrativi all’avvio. Ecco un esempio del file manifest generato automaticamente da Visual Studio 2012

<?xml version="1.0" encoding="utf-8"?>
<asmv1:assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1"
xmlns:asmv1="urn:schemas-microsoft-com:asm.v1"
xmlns:asmv2="urn:schemas-microsoft-com:asm.v2"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<assemblyIdentity version="1.0.0.0" name="MyApplication.app" />
<trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
<security>
<requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
<!-- UAC Manifest Options
If you want to change the Windows User Account Control level replace the
requestedExecutionLevel node with one of the following.
<requestedExecutionLevel level="asInvoker" />
<requestedExecutionLevel level="requireAdministrator" />
<requestedExecutionLevel level="highestAvailable" />
If you want to utilize File and Registry Virtualization for backward
compatibility then delete the requestedExecutionLevel node.
-->
<requestedExecutionLevel level="asInvoker" />
</requestedPrivileges>
<applicationRequestMinimum>
<defaultAssemblyRequest permissionSetReference="Custom" />
<PermissionSet ID="Custom" SameSite="site" />
</applicationRequestMinimum>
</security>
</trustInfo>
</asmv1:assembly>

Se il valore della proprietà requestedExecutionLevel viene cambiato da asInvoker a requireAdministrator, il sistema operativo all’avvio dell’applicazione mostra la canonica finestra per l’elevazione dei permessi. Nel caso in cui ci si trovi in modalità Debug ci verrà chiesto di riavviare Visual Studio 2012 in modalità modalità amministrativa

Build

La tab Build (denominata Compile quando siamo all’interno di un progetto Visual Basic) consente al programmatore di specificare le impostazioni sulle configurazioni di compilazione

Per esempio, l’impostazione Optimize code quando viene abilitata permette di generare file più piccoli e più performanti, tuttavia questo tipicamente incrementa i tempi di compilazione, quindi non è una impostazione consigliabile in fase di Debug.

Le altre impostazioni sono abbastanza intuitive e mi soffermo brevemente solo su Define DEBUG constant e Define TRACE constant. Quando abilitate queste impostazioni è possibile utilizzare nel codice impostazioni del tipo

#if(DEBUG)
MessageBox.Show("Sto utilizzando la costante DEBUG");
#endif

In questo caso il messaggio verrà visualizzato soltanto in modalità Debug e non in Release.

Debug

La tab Debug determina le modalità in cui l’applicazione viene eseguita quando viene lanciata internamente da Visual Studio 2012. Questa tab non è visibile nelle applicazioni web, in cui è sostituita dalla tab Web

Resources

La tab Resources consente di aggiungere al progetto o rimuovere dal progetto risorse come immagini, file di testo, icone o altri tipi di file

Settings

La tab Settings consente di impostare coppie nome/valore per impostazioni da utilizzare in fase di esecuzione di un’applicazione

Queste impostazioni sono in sola lettura in fase di esecuzione e possono essere variate soltanto modificando manualmente il file di configurazione ad esse associato.

In questa lezione abbiamo fatto una panoramica delle impostazioni più importanti relative alle proprietà di un progetto. Per approfondire la conoscenza di quest’area vi consiglio ci consultare la documentazione ufficiale Microsoft.

Intellisense

Uno degli obiettivi principali che da sempre contraddistinguono Visual Studio è quello di migliorare la produttività dei programmatori e in questo contesto possiamo inquadrare l’Intellisense. Con il progredire delle versioni del suo IDE, Microsoft ha migliorato sempre più tale funzionalità, che oggi è fondamentale per sviluppare più velocemente le applicazioni.

La più semplice funzionalità di questo strumento è la segnalazione di codice non corretto, che compare quando passiamo con il mouse su una porzione di codice sottolineata in rosso

Questo è possibile perché Visual Studio compila continuamente in background il codice che scriviamo e quindi conosce in anticipo qualsiasi cosa possa creare problemi nella fase di compilazione effettiva.

All’errore appena visto Visual Studio associa anche una cosiddetta smart tag che, cliccando sulla freccia rivolta in basso, offre alcune soluzioni correttive

La tecnologia smart tag non è limitata solamente al codice ma è possibile trovarla anche sui componenti visuali nella finestra di progettazione di Visual Studio 2012. Ecco ad esempio la smart tag di un controllo DataGridView

Sebbene le soluzioni appena viste siano molto utili, la potenza dell’Intellisense diviene evidente nel momento in cui si comincia a scrivere codice. Infatti man mano che scriviamo vengono visualizzati diversi menù a tendina per aiutarci a scegliere i giusti membri, funzioni, tipi di parametri riducendo i potenziali errori di compilazione futuri.

Se, ad esempio, proviamo a scrivere Conv ecco quello che ci comparirà

Dopo aver acquisito familiarità con questo strumento noterete come esso riduca in modo rilevante la quantità di codice da scrivere.

In Visual Studio 2012 l’Intellisense compare quando cominciamo a scrivere praticamente in qualsiasi punto della finestra di codice. Nelle vecchie versioni di Visual Studio la ricerca dei membri era effettuata su quelli che cominciavano con le stesse lettere digitate. A partire da Visual Studio 2010 questa funzionalità è stata modificata, includendo anche i membri che contengono le parole digitate e non solo quelli che cominciano con esse.

Questa differenza si evidenzia se proviamo a scrivere Console. in Visual Studio 2008 e 2012. Nella versione 2008 ecco come appare l’Intellisense

Nella versione 2012 invece avremo questa situazione

Chiaramente se non si vuole utilizzare questa funzionalità basta premere il tasto Esc e la lista dei suggerimenti scomparirà. Se invece selezioniamo un elemento facendo doppio click con il mouse o premendo il tasto Enter, il codice corrispondente verrà inserito nel punto selezionato.

Se scriviamo il nome di una classe seguito da un punto l’Intellisense ci mostra la lista di tutti i membri di quella classe

Visual Studio 2012 imposta un certo numero di opzioni predefinite per la gestione dell’Intellisense, ma è possibile cambiare le stesse attraverso la finestra di dialogo Options, accessibile dal menù TOOLS. Le prime opzioni da considerare sono quelle presenti nel menù Keyboard della sezione Environment

Tramite questo menù è possibile impostare o cambiare le scorciatoie da tastiera per i vari comandi. Ad esempio, il comando taglia (Edit.Cut) è solitamente impostato come Ctrl+X, ma da questa finestra è possibile cambiarlo

Tramite il menù All Languages della sezione Text Editor è possibile, tra le altre cose, impostare le opzioni per il completamento delle istruzioni per stabilire come debba essere visualizzata la lista dei membri

Per alcuni linguaggi esistono poi delle proprietà particolari in un menù apposito denominato appunto Intellisense

Un ultimo aspetto dell’Intellisense, che avremo modo di approfondire in seguito, sono i cosiddetti code snippets, ossia porzioni di codice che possono essere generate ed inserite automaticamente all’interno del nostro codice. Se ad esempio scriviamo for e premiamo due volte il tasto tab il risultato sarà il seguente

In pratica Visual Studio 2012 riconosce il tipo di costrutto e automaticamente inserisce il codice corrispondente. In questo caso conoscevamo la parola corrispondente al codice da inserire ma nel caso in cui non lo ricordassimo basta utilizzare la combinazione di tasti Ctrl+K+X e si aprirà un menù a tendina in cui selezionare il tipo di codice da inserire

Un’altra alternativa è quella di cliccare son il tasto destro del mouse all’interno dell’editor e selezionare nel menù contestuale che compare l’opzione Insert Snippet

I segnalibri (Bookmarks)

Infine per chiudere la presente lezione parliamo dei segnalibri (Bookmarks). I segnalibri in Visual Studio 2012 consentono di marcare punti del codice sorgente, in modo da poter successivamente tornare velocemente sugli stessi.

Per inserire o eliminare un segnalibro in una linea di codice basta utilizzare la combinazione di tasti Ctrl+K+K oppure selezionare l’opzione Toggle Bookmark nella sezione Bookmarks del menù Edit.

Il risultato dell’inserimento di segnalibri è il seguente

I segnalibri sono i rettangolini neri presenti nella barra laterale dell’editor.

Per visualizzare tutti i segnalibri inseriti nel nostro codice possiamo utilizzare la finestra View Bookmark, accessibile dal menù View selezionando l’opzione Other Windows

Facendo doppio click su un segnalibro verremo portati al corrispondente codice. Oppure possiamo scorrere in sequenza tutti i segnalibri definiti tramite le combinazioni di tasti Ctrl+K+P e Ctrl+K+N.

I code snippets

Come abbiamo detto più volte, uno dei principali vantaggi dell’uso di un ambiente di sviluppo integrato come Visual Studio 2012 rispetto ad un editor di testo tradizionale è che il primo è progettato per rendere i programmatori più produttivi, consentendo di scrivere codice più velocemente. Due degli strumenti più rilevanti da questo punto di vista in Visual Studio 2012 sono i code snippets ed il refactoring.

I code snippets sono, come abbiamo accennato in precedenza, fondamentalmente porzioni di codice che possono essere inserite all’interno del codice di un’applicazione e successivamente personalizzate in base ai requisiti dell’applicazione stessa. In particolare i code snippets vengono utilizzati per inserire le strutture di codice più utilizzate o quelle difficili da memorizzare.

I code snippets sono definiti in file XML, ognuno dei quali contiene un blocco di codice che i programmatori possono inserire all’interno delle proprie applicazioni, e sono integrati con l’Intellisense.

Visual Studio 2012 mette a disposizione molti snippet predefiniti, soprattutto per i due principali linguaggi del .NET Framework, il C# ed il VB.NET. Queste porzioni di codice sono organizzate gerarchicamente, per rendere più facile la ricerca di quelle più adatte ai propri scopi.

Per inserire uno snippet all’interno del nostro codice posizioniamoci nel punto esatto dell’editor di codice e utilizziamo la combinazione di tasti Ctrl+K+X

Esistono due alternative per l'inserimento di snippet. La prima consiste nel cliccare con il tasto destro del mouse nel punto dell’editor di codice in cui si vuole inserire e selezionare la voce Insert Snippet nel menù contestuale che compare

La seconda alternativa consiste nell’utilizzare il menù Edit selezionando la voce Intellisense e successivamente l’opzione Insert Snippet.

In ciascuno di questi casi Visual Studio 2012 mostra la lista di inserimento degli snippet. Scorrendo la lista e soffermandosi con il puntatore del mouse sulle varie voci viene mostrato un messaggio che indica la funzione dello snippet corrente e la scorciatoia che è possibile utilizzare per inserire lo stesso all’interno del codice

Per utilizzare la scorciatoia suggerita basta scriverla all’interno dell’editor di codice e poi premere due volte il tasto Tab. Nel caso dello switch dell’esempio precedente il risultato sarà

In Visual Studio 2012 la gestione degli snippet viene effettuata tramite il Code Snippets Manager. Per visualizzare questa finestra basta selezionare la voce corrispondente del menù Tools

Nella parte superiore di questa finestra è possibile selezionare il linguaggio di cui si vogliono visualizzare gli snippet (nel nostro caso Visual C#). Tramite il pulsante Add è possibile inserire nuovi file di snippet e tramite il pulsante Remove rimuoverli. In entrambi i casi le modifiche si rifletteranno nella lista degli snippet che visualizzeremo nell’editor di codice.

Refactoring

Con il nome di refactoring si intende invece il processo di revisione del codice al fine di migliorarne l’efficienza, senza cambiare però le funzionalità originarie dello stesso. Questo processo implica azioni quali semplificare un metodo, estrarre un porzione di codice ripetuto in più punti, ottimizzare una sezione di codice per renderlo più efficiente e così via.

Esistono diversi modi di richiamare le funzionalità di refactoring in Visual Studio 2012 e uno di questi è la selezione della voce Refactor del menù Edit

Le funzionalità disponibili sono quelle mostrate nell’immagine e adesso andremo ad analizzare più in dettaglio quelle più importanti.

La funzionalità Rename consente di rinominare un oggetto presente in più punti del codice. Basta selezionare l’oggetto e cliccare appunto su Rename.

La finestra di dialogo Rename è la seguente

Uno degli approcci migliori per ottimizzare un metodo complesso è quello di suddividerlo in più metodi più piccoli ed in quest’ottica un grande aiuto ci viene fornito dalla funzionalità Extract Method. Questa funzionalità può essere applicata selezionando la regione di codice da estrarre dal metodo e selezionando appunto la voce Extract Method dal menù Edit o dal menù contestuale che si apre cliccando con il tasto destro del mouse sul codice da estrarre.

Se, ad esempio, abbiamo il seguente metodo

possiamo selezionare la porzione di codice relativa all’if ed effettuare l’Extract Method. Ci comparirà la finestra di dialogo corrispondente in cui dovremo digitare il nome del nuovo metodo che verrà generato

Dopo aver cliccato su OK il risultato sarà il seguente

Vi faccio notare come questa funzionalità rilevi se siano presenti all’interno del codice da estrarre eventuali parametri e conseguentemente generi una firma del metodo con tali parametri (in questo caso un parametro string relativo alla stringa di connessione).

A volte si può presentare la necessità di riordinare i parametri, ad esempio di un metodo, soprattutto per motivi di leggibilità. Questa operazione si può effettuare selezionando un metodo ed effettuando l’operazione Reorder Parameters tramite la finestra di dialogo corrispondente

Una volta riordinati i parametri lo stesso ordine verrà riportato in tutti i riferimenti a tale metodo.La funzionalità Remove Parameters funziona in modo simile, consentendo di eliminare parametri da un oggetto e propagare tale modifica a tutti i relativi riferimenti.

In entrambi i casi prima di applicare le modifiche verrà mostrata un’anteprima delle stesse (se è selezionata l’opzione Preview reference changes)

La finestra Server Explorer

La finestra Server Explorer è una delle poche all’interno di Visual Studio 2012 a non essere specificatamente rivolta ad una soluzione o ad un progetto. Essa consente di esplorare ed interrogare le risorse hardware ed i servizi su computer locali o remoti.

Per visualizzare la finestra Server Explorer basta selezionare la relativa voce nel menù View. In essa sono presenti tre tipi di risorse su cui effettuare connessioni

Il nodo Servers consente di accedere a risorse hardware e servizi sul computer locale o su computer remoti. Il nodo Data Connections consente di gestire tutti gli aspetti correlati alle varie connessioni dati, inclusa la possibilità di creare database, creare e modificare tabelle, creare relazioni ed eseguire query. Infine il nodo SharePoint Connections consente di creare connessioni a server SharePoint e di accedere alle relative risorse.

Il nodo Servers sarebbe più corretto che fosse denominato Computers perché lo stesso può essere utilizzato per interrogare qualsiasi computer a cui abbiamo accesso, indipendente dal fatto che esso sia un server o una semplice postazione di lavoro desktop

Come possiamo vedere, ogni computer (in questo caso c’è solo il mio) corrisponde ad un sottonodo il quale a sua volta ha come sottonodi una lista di componenti relativi al computer stesso. Come impostazione predefinita viene sempre mostrato il computer locale ma si possono aggiungere quante altre macchine vogliamo cliccando con il tasto destro del mouse sul nodo Servers e selezionando la voce Add Server dal corrispondente menù contestuale

Cliccando su Add Server viene mostrata una finestra in cui occorre inserire il nome del computer o il corrispondente indirizzo IP

Cliccando su OK viene effettuato un tentativo di connessione con le nostre credenziali e se non abbiamo i sufficienti privilegi per accedere alla macchina possiamo provare a connetterci utilizzando un altro nome utente, basta cliccare sul link Connect using a different user name. Cliccando sul link ci viene mostrata la finestra per l’inserimento delle nuove credenziali

Ricordatevi sempre che è necessario possedere i privilegi amministrativi sulle macchine alle quali si vuole accedere tramite la finestra Server Explorer.

Andiamo adesso ad analizzare le caratteristiche di alcuni dei sottonodi del nodo relativo ad una specifica macchina, cominciando con il nodo Event Logs. Tale nodo, come suggerisce il nome, consente di accedere al log eventi di una macchina, per consultare il quale possiamo cliccare con il tasto destro del mouse sul nodo e selezionare la voce Launch Event Viewer

Quest’azione determina l’apertura della ben nota finestra di esplorazione degli eventi della macchina, che fornisce utili strumenti per la ricerca delle informazioni desiderate

L’alternativa è quella di espandere i sottonodi del nodo Event Logs e navigare per visualizzare le informazioni desiderate, un approccio che può risultare un po’ complicato come si intuisce dalla seguente immagine

Un altro importante nodo è quello denominato Management Class, che espone l’intera lista delle classi di gestione disponibili attraverso la finestra Server Explorer

Ogni sottonodo espone un insieme di funzionalità specifiche della macchina. Per esempio, cliccando con il tasto destro del mouse sul nodo Printers possiamo, impostare una nuova connessione ad una stampante (AddPrinterConnection)

Quando si sviluppa un’applicazione una delle cose più importanti è la sua manutenzione nel tempo. Spesso capita che un’applicazione funzioni per lungo tempo e ad un certo punto presenti dei problemi legati alle prestazioni. In questi casi può risultare difficile individuare le cause di questo mutamento.

In questi casi una strategia è quella di individuare dove si verifica il problema tramite i cosiddetti performance counters. Visual Studio 2012 mette a disposizione diversi performance counters predefiniti che è possibile visualizzare come sottonodi del nodo Performance Counters appunto

Questi elementi ci consentono di ottenere molte utili informazioni ed è possibile anche creare i propri performance counters. Cliccando con il tasto destro del mouse possiamo creare una nuova categoria di counters, mentre cliccando con il tasto destro del mouse su una categoria possiamo vedere i suoi dettagli

Il nodo Services mostra invece i servizi registrati sul computer. Alla sinistra di ogni servizio un’icona di stato indica lo stato del servizio stesso

Tutte le informazioni che è possibile consultare attraverso i nodi che abbiamo visto sono molto utili, ma potremmo ottenere le stesse informazioni attraverso il pannello di controllo di Windows o attraverso le proprietà del nostro sistema, ad esempio. L’aspetto più interessante per i programmatori è invece la possibilità di integrare questi informazioni nelle nostre applicazioni.

Adesso vedremo un esempio focalizzato sul nodo Management Classes ma lo stesso principio vale, con qualche piccola differenza, anche per gli altri nodi della finestra Server Explorer.Se espandiamo il nodo MyComputer, visualizziamo un nodo con il nome del nostro computer locale (nel mio caso ADMINISTRATOR)

Creiamo una semplice applicazione Windows Form e trasciniamo il nodo all’interno della finestra di progettazione. Quello che noteremo sarà l’inserimento di un componente denominato computerSystem1 all’interno dell’area non visuale del form

Se guardiamo la finestra Solution Explorer vedremo che è stato aggiunto un componente denominato root.CIMV2.Win32_ComputerSystem

Questo componente include le classi da utilizzare per ottenere e gestire all’interno delle nostre applicazioni le informazioni sulla macchina locale.

Se infatti selezioniamo il componente computerSystem1 presente nell’area non visuale del form e visualizziamo le proprietà vedremo che esse si riferiscono al nostro computer locale

E quindi dal codice sorgente possiamo accedere a queste informazioni.

Applicazioni Windows Form

Nelle prossime lezioni vedremo le caratteristiche di alcuni dei tipi di progetto messi a disposizione da Visual Studio 2012, ovviamente analizzarli tutti sarebbe impossibile in questa sede. In tutte le sue versioni Visual Studio è sempre stato uno strumento eccellente per lo sviluppo rapido di applicazioni per Windows. A tale scopo la finestra di progettazione (designer) della versione 2012 dell’IDE offre molteplici funzionalità per la creazione della parte visuale delle applicazioni, dalla possibilità di trascinare i componenti dal Toolbox all’area di progettazione, all’impostazione delle proprietà e dei comportamenti dei controlli.

Per cominciare a sviluppare un’applicazione Windows il primo passo è quello di creare un nuovo progetto Windows Form. Quindi in Visual Studio 2012 clicchiamo sul link New Project della pagina iniziale (oppure effettuiamo questa operazione dal menù FILE) e nella finestra New Project selezioniamo il tipo di progetto Windows Form Application, impostiamo il nome del progetto e la versione del .NET Framework da utilizzare e clicchiamo su OK

Quando si crea un nuovo progetto Windows Form, Visual Studio 2012 crea automaticamente un form vuoto (denominato Form1) pronto per essere modificato secondo le esigenze del programmatore

Per modificare l’aspetto visuale di un form abbiamo due possibilità: una è quella di ridimensionare e spostare attraverso il mouse il form e gli oggetti in esso contenuti, come normalmente ridimensioniamo e spostiamo qualsiasi finestra di Windows; l’altra è quella di agire sulle proprietà (tipicamente Size e Location) del form o dei controlli all’interno della finestra delle proprietà

Per quanto riguarda il ridimensionamento attraverso il mouse, quando selezioniamo un form o un controllo possiamo notare la comparsa ai suoi lati di alcuni quadratini bianchi a partire dai quali, tenendo premuto il mouse e spostandolo, possiamo cambiare le forme dell’oggetto nel modo desiderato

Nella finestra delle proprietà, come abbiamo visto in precedenza, possiamo visualizzare le voci in elenco alfabetico o raggruppate in categorie. Raggruppando le voci possiamo individuare le tre categorie più rilevanti dal punto di vista dell’aspetto del form: Appearance, Layout e Windows Style.

La categoria Appearance include le proprietà per l’impostazione dei colori, dei caratteri e dello stile di un form. In molte applicazioni la maggior parte di queste proprietà viene lasciata ai valori predefiniti. Una proprietà di questa categoria che tipicamente viene sempre variata è la proprietà Text perché essa rappresenta il testo che verrà visualizzato nella barra dell’applicazione

Se si ha la necessità di un form di dimensione fissa o con un bordo particolare possiamo agire sulla proprietà FormBorderStyle

La categoria Layout, oltre alle già citate proprietà Size e Location, include anche le proprietà MaximumSize e MinimumSize, che consentono di controllare le dimensioni massime e minime di un form.

Le proprietà StartPosition and Location consentono invece di stabilire la posizione iniziale del form all’avvio dell’applicazione, mentre la proprietà WindowState consente di impostare se all’avvio il form debba essere minimizzato, massimizzato o nelle dimensioni specificate dalla proprietà Size

La categoria Window Style include proprietà che determinano cosa debba essere mostrato nella barra dell’applicazione, inclusi i box per minimizzare o massimizzare il form, il pulsante Help e l’icona associata al form

La proprietà ShowInTaskbar determina se il form debba essere o meno visualizzato nella taskbar di Windows, mentre la proprietà TopMost permette di stabilire se il form debba sempre apparire sopra le altre finestre aperte.

E’ possibile modificare alcune impostazioni dell’IDE di Visual Studio 2012 per rendere la fase di implementazione grafica più semplice secondo le preferenze di ogni programmatore. Infatti nella già vista finestra delle opzioni (accessibile dal menù TOOLS cliccando sulla voce Options) sono presenti due schede relative a quest’area

Aggiunta e posizionamento dei controlli Windows Form

All’interno di un Windows Form è possibile inserire due tipi di controlli: quelli visuali, che vengono materialmente visualizzati sul form, e quelli che non hanno un’interfaccia grafica da visualizzare sul form.

Per aggiungere un controllo visuale si può procedere o facendo doppio click su di esso all’interno del Toolbox (e in questo caso esso verrà posizionato in un punto predefinito del form), oppure cliccando e trascinandolo dal Toolbox al punto desiderato del form.

Mentre spostiamo un controllo su un form vengono visualizzate delle linee guida che ci indicano la giusta posizione in cui dovrebbe essere posto lo stesso. Ad esempio, nell’immagine seguente le due linee indicano la distanza minima consigliata dai bordi del form

Queste linee guida funzionano sia per il posizionamento che per il ridimensionamento dei controlli e ovviamente il loro numero cresce al crescere del numero di elementi presenti sulla superficie del form

Le linee guida sono molto utili anche per l’allineamento orizzontale o verticale dei controlli.

Visual Studio 2012 mette a disposizione molti utili strumenti per formattare automaticamente la posizione e la forma dei controlli che piazziamo all’interno di un form. Uno di questi è il menù FORMAT, accessibile solo quando siamo nella finestra di progettazione grafica (Design view)

Come possiamo vedere abbiamo funzionalità per l’allineamento, il ridimensionamento, la spaziatura e via dicendo. Se ad esempio abbiamo una situazione del genere

e vogliamo che tutti i controlli TextBox assumano le stesse dimensioni del controllo button3, basta selezionare tutti i controlli (a partire dal button3) e poi nel menù FORMAT selezionare la voce Make Same Size e la sottovoce Width (larghezza) per avere il seguente risultato

Vi faccio notare che quando selezioniamo più controlli tenendo premuto il tasto Ctrl e cliccando su di essi con il mouse, uno di essi risulterà circondato dai quadratini di ridimensionamento bianchi e gli altri da quelli neri

Questo indica che le operazioni del menù FORMAT verranno applicate prendendo come riferimento il controllo con i quadratini bianchi.

Allo stesso modo è possibile effettuare l’allineamento automatico di gruppi di controlli, semplicemente selezionandoli e poi cliccando sulle sottovoci della voce Align del menù FORMAT

Molti utenti trovano più veloce utilizzare la testiera (il tasto Tab) invece che il mouse quando utilizzano un’applicazione, in particolare quelle applicazioni che richiedono l’inserimento di molti dati con lo spostamento da un campo ad un altro. Quindi è molto importante che quando si preme il tasto Tab il cursore si sposti da un campo ad un altro nella maniera che l’utente si aspetta.

L’ordine in cui il cursore si sposta da un campo all’altro è denominato tab order e come impostazione predefinita esso viene impostato nello stesso ordine con cui i controlli vengono inseriti nel form. A partire dal valore zero ad ogni controllo viene assegnato a questo scopo un valore nella proprietà TabIndex.

Oltre a poter modificare la proprietà TabIndex di ogni controllo tramite la finestra delle proprietà, Visual Studio 2012 fornisce un utile strumento per rendere questa operazione molto più semplice ed immediata. Basta infatti utilizzare il menù VIEW, selezionare la voce Tab Order e alla sinistra di ogni controllo comparirà un quadratino con il corrente valore della proprietà TabIndex

A questo punta basta cliccare con il mouse sui controlli nell’ordine che vogliamo che assuma il tab order e il gioco è fatto. Dopo aver cliccato sul controllo, il quadratino cambierà valore e colore, da blu a bianco. Quando abbiamo finito basta cliccare sul tasto Esc.

A volte si può presentare di bloccare un controllo in una determinata posizione per evitare di spostarlo inavvertitamente. In tal caso possiamo utilizzare la funzionalità Lock Controls del menù FORMAT. Quando uno o più controlli vengono bloccati è possibile selezionarli per cambiare le loro proprietà, ma non è possibile utilizzare il mouse per muoverli o ridimensionarli. Se i controlli di un form sono bloccati quando essi vengono selezionati compare il simbolo di un piccolo lucchetto

Una cosa da evidenziare è che anche se i controlli sono bloccati è possibile variare la loro posizione agendo sulla proprietà Location di ognuno di essi.

La finestra delle proprietà è un fondamentale strumento per impostare le xaratteristiche dei form e dei controlli e in aggiunta alle semplici proprietà in cui inserire un valore testuale Visual Studio 2012 mette a disposizione un certo numero di editor di specifici tipi di proprietà. Prendiamo ad esempio la proprietà Font di un controllo che può essere espansa per vedere e impostare tutte le proprietà ad essa correlate

Essa mette anche a disposizione un pulsantino ellipsis cliccando sul quale viene aperto un editor ad hoc, sottoforma di finestra di dialogo, che consente di agire sui parametri in modo molto più semplice e veloce

Questo è solo uno dei tanti editor a disposizione e vi invito a verificare durante l’uso di Visual Studio 2012 quali proprietà siano dotate di un editor specifico.

Come abbiamo detto in precedenza, oltre ai componenti visuali, come quelli che abbiamo appena visto, in un form possono essere inseriti componenti non visuali, basati su servizi. Tra questi abbiamo i controlli Timer, ErrorProvider, i vari controlli relativi a dialog predefinite e cosi via. Quando si fa doppio click su di essi (o si trascinano sul form) viene creata un’area sottostante la finestra di progettazione e vengono inserite lì le istanze dei vari componenti

Selezionando ognuno di questi controlli le relative proprietà potranno essere gestite nella finestra delle proprietà proprio come per i controlli visuali.

I controlli container

I controlli di tipo container (contenitori) sono progettati per facilitare l’impostazione dell’aspetto e del layout dei nostri form. Essi servono a raggruppare e contenere insiemi di controlli in modo che se, ad esempio, si volessero spostare tutti assieme basterebbe soltanto spostare il container. Utilizzando poi le proprietà Dock e Anchor, come vedremo, è possibile far si che intere sezioni dei nostri form si ridimensionino automaticamente durante l’esecuzione dell’applicazione, in risposta al ridimensionamento del form.

Adesso vedremo alcuni dei controlli di tipo container.

Panel e SplitContainer

Il controllo Panel viene utilizzato per raggruppare componenti in qualche modo correlati. Quando viene inserito all’interno di un form questo controllo può assumere qualsiasi dimensione e posizione all’interno dello spazio a disposizione. Poiché si tratta di un contenitore, cliccando al suo interno viene selezionato tutto il suo contenuto, inoltre per spostarlo con tutto il suo contenuto quando lo selezioniamo Visual Studio 2012 mostra un’icona in alto a sinistra attraverso cui è possibile trascinarlo dove vogliamo

Il controllo SplitContainer crea automaticamente due controlli Panel e suddivide il proprio spazio in due sezioni, una per ogni pannello

Sia in fase di progettazione che in fase di esecuzione è possibile ridimensionare i due spazi semplicemente spostando la barra che si trova tra i due pannelli. I due pannelli possono essere posti orizzontalmente o verticalmente e a loro volta possono contenere altri controlli SplitContainer, per creare form con determinati layout più complessi. Cliccando sull’icona dello smart tag in alto a destra possiamo impostare appunto l’orientazione dei pannelli e stabilire se il controllo debba essere fissato (Dock) al form

FlowLayoutPanel

Il controllo FlowLayoutPanel consente di creare form con un’impostazione grafica simile ad un browser web. Invece di posizionare manualmente ogni controllo al suo interno, Visual Studio semplicemente imposta ogni componente che viene aggiunto in sequenza nello spazio disponibile successivo. Se, ad esempio, aggiungiamo tre controlli Button in sequenza ecco come li posizionerà Visual Studio

Come impostazione predefinita i controlli vengono posizionati da sinistra verso destra e successivamente dall’alto verso il basso, ma è possibile modificare tale comportamento agendo sulla proprietà FlowDirection del container.

Se nel caso del nostro esempio modifichiamo tale proprietà al valore TopDown il risultato sarà il seguente

TableLayoutPanel

Un’alternativa ai controlli appena visti è il controllo TableLayoutPanel. Questo controllo funziona in modo molto simile ad una tabella di Microsoft Word, in cui ogni cella funziona come un contenitore per un singolo controllo. Quando si inserisce un controllo in una cella esso viene automaticamente posizionato nel suo angolo superiore sinistro

Per modificare questo posizionamento possiamo agire sulla proprietà Dock dei vai controlli.

Come impostazione predefinita un controllo TableLayoutPanel viene impostato con due righe e due colonne ma cliccando sul suo smart tag possiamo aggiungere o eliminare una riga al volo oppure possiamo aprire la finestra di configurazione del controllo

In particolare dalla finestra di configurazione del controllo possiamo impostare varie proprietà per le righe e le colonne

Per chiudere la presente lezione ci soffermeremo su due proprietà che ho spesso citato, Dock e Anchor. Infatti creare dei layout di controlli per le dimensioni che i form assumono in fase di progettazione non è sufficiente, perché in fase di esecuzione i form vengono ridimensionati dagli utenti e la cosa ideale sarebbe che anche i controlli si ridimensionassero di conseguenza. A questo servono le due suddette proprietà.

La proprietà Dock permette di impostare a quale lato di un container un controllo debba essere appoggiato

La proprietà Anchor invece determina a quale lato del container un controllo debba essere ancorato e non necessariamente appoggiato

L’impostazione di queste due proprietà è fondamentale per il corretto ridimensionamento di controlli in fase di esecuzione di un’applicazione e quindi vi invito ad effettuare diverse prove sulle relative impostazioni.

Windows Presentation Foundation (WPF)

Quando vogliamo sviluppare un’applicazione per sistemi Windows una tecnologia alternativa alle classiche applicazioni Windows Form, che abbiamo visto nelle lezioni precedenti, è la Windows Presentation Foundation (WPF). Questa tecnologia è estremamente potente, flessibile ed è stata progettata per superare alcune limitazioni delle applicazioni Windows Form.

In un certo senso si può dire che la tecnologia WPF rappresenti l’evoluzione della tecnologia Windows Form, sebbene i rispettivi componenti siano abbastanza differenti. Nella presente lezione vedremo come creare una semplice applicazione WPF in Visual Studio 2012, lasciando poi a voi il compito di effettuare tutte le prove ed i test che desiderate, un po’ come abbiamo fatto nelle lezioni sui Windows Form.

Windows Presentation Foundation è un vero e proprio framework. Mentre le applicazioni Windows Form utilizzano come motore grafico GDI, WPF è dotato di un proprio motore grafico che non si basa sulla classica creazione di finestre e controlli di Windows. In Windows Form solitamente si definisce l’interfaccia utente tramite la finestra di progettazione visuale (designer) e questo automaticamente genera il corrispondente codice in un file con estensione .designer, quindi l’interfaccia utente in pratica viene definita e gestita in C# o VB.

Invece in WPF le interfacce vengono definite in un linguaggio, simile all’XML, denominato XAML (Extensible Application Markup Language) e progettato a questo scopo da Microsoft. Questo linguaggio consente una grande flessibilità, permettendo lo sviluppo di interfacce molto più avanzate di quanto si possa fare con i Windows Form.

Dopo questa piccola introduzione creiamo il nostro primo progetto WPF e quindi nella finestra New Project scegliamo il modello WPF Application, diamo un nome alla nostra applicazione e clicchiamo su OK

Visual Studio 2012 crea una struttura del progetto simile alla seguente

Come possiamo vedere nella finestra Solution Explorer, all’interno del progetto sono presenti due file, App.xaml e MainWindow.xaml, ognuno dei quali ha un file di codice collegato (nel nostro caso con estensione .cs perché utilizziamo il linguaggio C#)

Nella fase iniziale il file App.xaml contiene un elemento Application XAML che espone un attributo, denominato StartupUri, utilizzato per definire quale file XAML debba essere eseguito per primo all’avvio dell’applicazione (come impostazione predefinita è impostato il file MainWindows.xaml)

Questo è equivalente a quello che abbiamo visto essere il form di avvio (startup form) in un progetto Windows Form.

Tornando all’ambiente di sviluppo, possiamo notare che il Toolbox è popolato da controlli WPF molto simili concettualmente ai corrispondenti in Windows Form, mentre la finestra delle Proprietà è abbastanza diversa, come vedremo in seguito. Inoltre possiamo notare come la finestra di progettazione centrale sia suddivisa in due aree, una grafica e una contenente il corrispondente codice.

Chi ha familiarità con il linguaggio XML troverà molto più facile la comprensione del linguaggio XAML. In questo linguaggio è consentito un solo nodo radice e gli elementi sono nidificati uno dentro l’altro, per definire la struttura ed il contenuto dell’interfaccia utente. Ogni elemento XAML è mappato su una classe .NET ed i relativi attributi sono mappati su proprietà (o eventi) della classe stessa. Attenzione che i nomi degli elementi e degli attributi sono case-sensitive.

Osserviamo il codice XAML del file MainWindow

Window è il nodo radice e al suo interno è presente un elemento Grid. Questo definisce la presenza di una griglia all’interno della finestra. Questo nodo è legato alla propria classe contenente codice tramite l’attributo x:Class e contiene anche alcune dichiarazioni e proprietà quali Title, Height e Width. I valori degli attributi devono essere delimitati da doppi apici. Il nome di un controllo viene impostato tramite la proprietà x:Name.

Controlli WPF

Come detto, WPF mette a disposizione tanti controlli da utilizzare nella definizione delle nostre interfacce utente

Sebbene i controlli WPF siano comparabili a quelli Windows Form, le loro proprietà sono abbastanza differenti da quelle della controparte. Per esempio, in molto controlli non è presente la proprietà Text ma è possibile invece trovare la proprietà Content, utilizzata per assegnare un contenuto ad un controllo. E’ possibile utilizzare tale proprietà allo stesso modo della proprietà Text dei Windows Form, ma in realtà la proprietà Content è molto più potente poiché accetta come valore qualsiasi elemento WPF, consentendo di personalizzare la struttura di un controllo senza la necessità di crearne uno ad hoc

Se osserviamo le proprietà di un controllo Button mostrate nell’immagine precedente noteremo che esso non espone la proprietà Image, molto usata in Windows Form per associare un’immagine ad un pulsante. Questo potrebbe sembrare un limite, ma nuovamente ci torna utile la proprietà Content. Poiché infatti tale proprietà consente l’assegnazione di qualsiasi controllo WPF, è possibile associare al Button un controllo Image per ottenere lo stesso risultato della proprietà Image. Questo approccio inizialmente potrebbe apparire più astruso, ma in realtà esso consente di gestire nel modo desiderato l’intero layout di un controllo.

Ad esempio, con il seguente codice

<Button HorizontalAlignment="Left" VerticalAlignment="Top" Width="100" Height="30">
<Button.Content>
<StackPanel Orientation="Horizontal">
<Image Source="Resources/FloppyDisk.ico" Width="16" Height="16" />
<TextBlock Margin="5,0,0,0" Text="Save" VerticalAlignment="Center" />
</StackPanel>
</Button.Content>
</Button>

Avremo il seguente controllo Button

Dobbiamo citare anche le due proprietà IsEnabled (che corrisponde all’Enabled in Windows Form) e Visibility (che corrisponde al Visible in Windows Form). La prima si differenzia da quella presente in Windows Form solo per il prefisso Is (presente anche in altre proprietà), mentre la seconda non è un valore booleano in WPF ma può assumere i valori Visible, Hidden o Collapsed.

Come abbiamo avuto modo di vedere, nello sviluppo in Windows Form il posizionamento dei controlli sulla superficie di un form è assoluto, sebbene attraverso i controlli TableLayoutPanel e FlowLayoutPanel sia possibile gestire in modo più efficiente questo aspetto. In WPF la situazione è diversa perché in tale contesto è presente un certo numero di controlli progettati specificatamente per definire il layout ed il posizionamento di altri controlli.

Questi controlli non sono visibili all’utente ma consentono di gestire la posizione dei controlli presenti sulla propria superficie. In WPF infatti non esiste una superficie predefinita per il posizionamento dei controlli, questo spiega perché nel codice della pagina MainWindow è presente un controllo Grid. Se infatti trasciniamo dal Toolbox un controllo Button sulla superficie di progettazione il codice della pagina verrà modificato nel seguente modo

Come possiamo vedere il Button è stato posizionato all’interno del controllo Grid.Altri importanti controlli per la gestione del layout in WPF sono Canvas e StackPanel. Siccome però lo scopo della presente guida è quello di introdurvi alle varie aree di Visual Studio 2012 non possiamo soffermarci sui relativi particolari e vi invito ad approfondirne la conoscenza tramite la consultazione della documentazione ufficiale Microsoft.

Soffermiamoci adesso sulla finestra delle proprietà dei controlli WPF e per farlo selezioniamo il controllo Button che abbiamo inserito nel designer in precedenza. Possiamo subito notare che la proprietà Name del controllo non si trova in elenco ma è posta nella parte superiore della finestra e attraverso questa possiamo impostare il nome del controllo

Molto utile è il campo per la ricerca di una proprietà (Search Properties), che serve a filtrare la lista proprietà in base a quello che scriviamo al suo interno. Per quanto riguarda il funzionamento delle singole proprietà anche in questo caso vi rimando alla documentazione ufficiale Microsoft e alle vostre stesse prove.

In ogni nuova versione di Visual Studio la finestra di progettazione grafica (designer) WPF è stata migliorata, sia dal punto di vista della stabilità che delle prestazioni. Il layout di quest’area è simile al corrispondente dell’ambiente Windows Form, ma supporta tutta una serie di caratteristiche uniche.

La prima, che abbiamo già sottolineato, è la suddivisione della finestra in due aree, una per la progettazione visuale e una per il codice XAML. Chiaramente è possibile scambiare la posizione delle due aree e posizionarle verticalmente anziché orizzontalmente, semplicemente cliccando sulle corrispondenti icone

Se lo si preferisce, si può espandere una delle due aree facendo doppio click sulla corrispondente tab, e invece di lavorare con la vista in parallelo passare da una all’altra all’occorrenza.

Lavorare con l’editor XAML è in qualche modo simile a lavorare con l’editor HTML in Visual Studio. Sono stati apportati molti miglioramenti all’Intellisense di quest’area, rendendo la scrittura del codice più facile e veloce.

Sebbene sia importante familiarizzare con la scrittura di code XAML nel corrispondente editor, Visual Studio 2012 fortunatamente mette a disposizione un ottimo designer per WPF, del tutto paragonabile a quello per Windows Form.

Anche qui ad esempio quando selezioniamo, spostiamo e ridimensioniamo un controllo compaiono opportune linee guida

Strumenti per la gestione di database

La connettività ai database è un aspetto essenziale nella stragrande maggioranza delle applicazioni. Quando Visual Studio fu introdotto per la prima volta esso fornì ai programmatori diverse funzionalità per gestire i file dei database sul file system o sui server locali, per il controllo dei dati e per il legame degli stessi a componenti delle applicazioni (il cosiddetto data-bound). Fu a tale scopo introdotto il framework ADO.NET, fondamentale per l’interfacciamento con i vari tipi di database.

Con la versione 2010 di Visual Studio queste caratteristiche sono state raffinate e sono state introdotte nuove funzionalità per consentire un più semplice accesso ai dati da parte delle applicazioni. Visual Studio 2012 ha proseguito lungo questa strada, aggiungendo utili strumenti per la progettazione di tabelle e la gestione di oggetti SQL Server in genere.

La prima finestra che andiamo ad analizzare è la finestra Server Explorer, che abbiamo già incontrato in precedenza e come abbiamo appunto detto serve ad esplorare i componenti del proprio sistema e dei sistemi cui è possibile connettersi. In particolare un elemento fondamentale è il nodo Data Connections, attraverso cui Visual Studio 2012 mette a disposizione un significativo numero di funzionalità appartenenti ad altri applicativi, come SQL Server Management Studio, per la gestione di database.

Se sulla nostra macchina (o su una macchina comunque raggiungibile dalla nostra) vogliamo accedere al database AdventureWorks di un’istanza di SQL Server dobbiamo cliccare con il tasto destro del mouse sul nodo Data Connections e selezionare la voce Add Connection. Fatto questo ci viene mostrata una finestra di dialogo in cui dobbiamo scegliere il tipo di origine dati (Data source)

Nel nostro caso scegliamo l’opzione Microsoft SQL Server ma come possiamo vedere sono disponibili connettori per diversi tipi di origine dati e comunque è possibile importarne anche altri. Dopo aver selezionato l’origine dati clicchiamo su Continue e ci viene mostrala la finestra Add Connection

In questa finestra inseriamo i riferimenti della macchina a cui dobbiamo collegarci, scegliamo il tipo di autenticazione, selezioniamo il database AdventureWorks e clicchiamo su OK. A questo punto Visual Studio 2012 prova a connettersi al database e se tutto va a buon fine aggiunge un nodo ad esso relativo al nodo Data Connections

Come possiamo vedere, vengono mostrati tutti gli oggetti fondamentali del database, incluse tabelle, viste, procedure e funzioni. Espandendo i vari nodi possiamo accedere ad ognuno di tali elementi. Ad esempio, se espandiamo il nodo Tables possiamo individuare la tabella Employee e se espandiamo il nodo ad essa relativo possiamo vederne tutti i relativi campi

Vediamo adesso come operare sui vari oggetti. Il modo più semplice di modificare una tabella (consideriamo sempre la tabella Employee) è quello di fare doppio click sul corrispondente nodo all’interno della finestra Server Explorer. In questo modo viene visualizzata una finestra di modifica costituita da due aree principali

Nella parte superiore si trova l’area in cui è presente l’elenco delle colonne della tabella, con il relativo tipo di dati e la specifica sull’accettazione o meno dei valori NULL. In quest’area è possibile aggiungere, modificare ed eliminare colonne. Nell’area sottostante invece è possibile modificare tutte le proprietà del campo correntemente selezionato.

Analogamente per modificare viste, procedure, funzioni e relazioni basta individuare il corrispondente oggetto nell’albero e fare doppio click su di esso. Se, ad esempio, facciamo doppio click sulla cista vEmployee comparirà l’area di modifica delle viste in cui è possibile operare sia graficamente, attraverso il diagramma in alto, sia manualmente, attraverso il codice T-SQL sottostante

Visual Studio 2012 consente anche di modificare i dati presenti nelle tabelle di un database. Basta cliccare sulla tabella interessata e selezionare nel menù contestuale la voce Show Table Data. In questo modo comparirà una tabella di cui potremo editare il contenuto secondo le nostre esigenze

Chiaramente non è scopo della presente guida la spiegazione delle varie operazioni che è possibile effettuare su un database e pertanto vi invito a consultare la documentazione ufficiale Microsoft per approfondire tali tematiche.

Dataset e Databinding

La maggior parte delle applicazioni utilizza una qualche sorta di archiviazione di dati. Questo può avvenire sottoforma di oggetti serializzati o dati XML, ma per sistemi che richiedono un’archiviazione di dati a lungo termine e l’accesso agli stessi da parte di un grande numero di utenti è più opportuno utilizzare un database. Il .NET Framework, come vedremo a breve, fornisce un grande supporto per la gestione di database e altre origini dati.

Lo strumento principale per la gestione di un database in Visual Studio 2012 è il DataSet, un oggetto complesso che corrisponde ad una rappresentazione in memoria di un database. Al suo interno sono presenti oggetti DataTable, che corrispondono alle tabelle del database, e ciascuna di queste contiene DataColumn, che definiscono la composizione delle righe della DataTable, denominate DataRow. E’ possibile definire relazioni tra le DataTable di un DataSet, allo stesso modo di quanto avviene in un database.

Adesso vedremo come creare e gestire un DataSet. Avviamo Visual Studio 2012 e creiamo una nuova applicazione Windows Form, denominata Clienti. Nella finestra Solution Explorer clicchiamo con il tasto destro del mouse sul progetto e selezioniamo la voce Add e poi New Item. Nella finestra di dialogo Add New Item selezioniamo il nodo Data e tra le voci disponibili DataSet

Diamo un nome al DataSet (nel mio caso DataSetClienti) e clicchiamo su Add. Nella finestra Solution Explorer dovremmo ora vedere qualcosa del genere

Se facciamo doppio click sulla voce DataSetClienti.xsd nella parte centrale dell’IDE viene visualizzato il DataSet vuoto

Il prossimo passo è quello di definire la connessione ad un database nella finestra Server Explorer, come abbiamo visto nella lezione precedente. Creiamo dunque una connessione al database AdventureWorks di SQL Server

Il passo successivo è quello di specificare quali dati dovranno essere estratti da questo database. A tale scopo selezioniamo la tabella Person dal nodo Tables e trasciniamola nell’area dell’editor del DataSet. Quando viene inserito un oggetto appartenente ad un database in quest’area viene creata e salvata una stringa di connessione al database nelle setting del file di configurazione dell’applicazione. In questo caso nel DataSet avremo la seguente situazione

Mentre nelle setting dell’applicazione troviamo la stringa di connessione

Nell’area di progettazione del DataSet Visual Studio 2012 ha creato la DataTable fortemente tipizzata Person ma anche un TableAdapter, denominato PersonTableAdapter, da utilizzare per estrarre ed aggiornare i dati del database. Se inseriamo più tabelle all’interno del DataSet avremo un TableAdapter per ognuna di esse. Per ogni TableAdapter vengono creati automaticamente i metodi Fill e GetData che è possibile utilizzare per estrarre dati dal database.

Questi due metodi vengono accoppiati perché utilizzano la stessa query e se li selezioniamo possiamo modificare tale query nella finestra Properties (proprietà CommandText)

Se clicchiamo sulla destra della proprietà CommandText compare il pulsantino ellipsis

Cliccando questo pulsante viene aperta la finestra Query Builder, tramite la quale possiamo modificare la query a nostro piacimento

Se invece clicchiamo sul PersonTableAdapter e ne visualizziamo le proprietà vediamo che in esso sono state preconfigurate istruzioni di Insert, Update e Delete sul database che possiamo modificare come abbiamo visto per l’istruzione Select

DataBinding

Le applicazioni di uso più comune, soprattutto quelle gestionali, solitamente estraggono dati, consentono la visualizzazione di tali dati in diversi modalità e, cosa fondamentale, permettono la modifica degli stessi trasmettendo i cambiamenti al database. Il passaggio relativo alla connessione tra i dati presenti in memoria e gli elementi visuali che li rappresentano è denominato DataBinding.

Ritornando all’applicazione della lezione precedente, adesso vedremo come gestire i dati della tabella Person. Apriamo il designer del form che Visual Studio 2012 ha generato automaticamente quanto abbiamo creato il progetto Clienti (Form1)

Dal menù View apriamo la finestra Data Sources che mostra il contenuto del nostro DataSet

Clicchiamo sul pulsante con la freccia alla destra della DataTable Person e selezioniamo l’opzione Details

Facciamo la stessa cosa per le colonne che non vogliamo gestire (ad esempio rowguid e ModificedDate) selezionando per ognuna di esse il valore None. A questo punto trasciniamo il nodo Person sull’area del nostro form, il risultato dovrebbe essere simile al seguente

In pratica Visual Studio 2012 ha generato automaticamente i controlli correlati ai vari campi della tabella. Se invece dell’opzione Details avessimo impostato per il nodo l’opzione DataGridView al posto dei controlli sarebbe stata creata una griglia con i campi della tabella.

A questo punto senza aver scritto una riga di codice manualmente possiamo avviare l’applicazione e navigare sui dati della tabella tramite il controllo di navigazione posto automaticamente nella parte superiore del form

Cominciamo ad analizzare quello che Visual Studio 2012 ha fatto. Innanzitutto osserviamo che tra gli elementi inseriti automaticamente nel form sono presenti un’istanza del DataSet (clientiDataSet) e un’istanza del PersonTableAdapter (personTableAdapter)

Se apriamo il file di codice Form1.cs vedremo che nell’evento Load del form Visual Studio ha inserito il seguente codice

Quindi in pratica all’avvio dell’applicazione (Load) viene chiamato il metodo Fill del personTableAdapter che esegue la query definita nel relativo CommandText per popolare la tabella Person dell’istanza del DataSet dataSetClienti.

Il prossimo elemento da analizzare è il personBindingSource, un’istanza della classe BindingSource del .NET Framework. Questo controllo consente di collegare i controlli presenti sulla superficie del form con unità di dati (in questo caso con i dati della DataTable Person). Osserviamo le proprietà di tale oggetto

Le due proprietà più importanti sono DataSource e DataMember. La prima consente di impostare la sorgente dati, che nel nostro caso è dataSetClienti

La seconda proprietà consente di impostare la tabella appartenente all’origine dati appena selezionata (nel nostro caso Person)

Se adesso guardiamo le proprietà di ogni singolo controllo, ed in particolare la sezione DataBindings, vediamo che ogni controllo è collegato al corrispondente campo della tabella Person e se non lo fosse dovremmo collegarlo

Altro elemento molto importante è il personBindingNavigator, un’istanza della classe BindingNavigator, che visivamente corrisponde alla barra degli strumenti che Visual Studio 2012 ha automaticamente posizionato nella parte superiore del form

Questa barra presenta una serie di pulsanti per scorrere i record, aggiungere o cancellare un record e salvare le modifiche applicate ai dati. Infatti se osserviamo la finestra delle proprietà del controllo vediamo come ad ogni funzionalità è associato un elemento (item)

Nel gruppo Items ogni proprietà definisce un’azione ed il valore della proprietà indica l’elemento a cui l’azione è collegata. Per esempio, consideriamo il controllo BindingNavigatorAddNewItem. Quando l’applicazione viene avviata esso viene assegnato alla proprietà AddNewItem e sull’evento Click del controllo viene chiamato il metodo OnAddNew, che inserisce un nuovo elemento all’interno del BindingSource sottostante. Il funzionamento degli altri controlli della barra è analogo.

L’unico controllo della barra che Visual Studio imposta diversamente è quello relativo al salvataggio. Se infatti facciamo doppio click sull’icona relativa viene aperta la finestra dell’editor in cui vediamo il seguente codice

Come possiamo vedere il suddetto codice effettua tre passaggi: viene validato il form, vengono trasmesse all’origine dati le modifiche fatte al BindingSource e viene chiamato il metodo UpdateAll dell’oggetto tableAdapterManager (altra istanza creata da Visual Studio quando abbiamo inserito nel form i campi della DataTable) sull’istanza del DataSet. Questi passaggi determinano il salvataggio delle modifiche effettuate sui dati del database.

Chiaramente i vari metodi predefiniti possono essere sostituiti da codice scritto da noi. Se, ad esempio, per aggiungere un nuovo elemento vogliamo scrivere il nostro codice e non utilizzare quello predefinito basta generare l’evento Click del controllo BindingNavigatorAddNewItem ed inserire al suo interno il codice che desideriamo

Windows Communication Foundation (WCF)

Fino a pochi anni fa una delle problematiche principali nello sviluppo di applicazioni avanzate era quello di mettere a disposizione i dati di determinate realtà ad ambienti esterni ad esse. A questa necessità, ed anche ad altre, è stata trovata una soluzione tramite i cosiddetti servizi.

I servizi permettono a diverse entità di ottenere dati ed effettuare determinate azioni, pur trovandosi a distanza dal sistema con cui interagiscono. Un esempio potrebbe essere una webcam posta in un luogo molto inospitale, che permette di osservare quello che succede in quel luogo comodamente seduti davanti allo schermo di un computer.

L’utilizzo dei servizi non è più complicato rispetto ad altri elementi del .NET Framework e per il loro utilizzo i passi fondamentali sono: individuare la posizione appropriata per collocare il servizio ed impostare nell’applicazione che lo utilizza un riferimento allo stesso.

Un servizio è fondamentalmente una funzionalità che viene resa disponibile a tutti coloro che ne fanno richiesta e a tal proposito si parla di applicazioni orientate ai servizi (SOA, service oriented application) in riferimento proprio ad applicazioni che aggregano logicamente un insieme di servizi. Il servizio può essere locale o remoto ed i fruitori dello stesso possono essere diversi, come applicazioni Windows Form, pagine ASP.NET o anche altri servizi.

Questo strumento è utilizzato in tantissimi ambiti, senza che gli utenti ne abbiano consapevolezza. Molte compagnie, ad esempio, utilizzano i servizi web (web service) per esporre i propri database per vari usi. Sicuramente vi sarà capitato più di una volta di effettuare gli aggiornamenti di Windows (Windows Update). Ebbene essi vengono realizzati tramite l’uso di un servizio specifico.

Le applicazioni per comunicare con servizi residenti su server web utilizzano protocolli internet (come HTTP e SOAP). Un ruolo fondamentale in questo processo di comunicazione è svolto dal linguaggio XML, utilizzato per lo scambio delle informazioni (infatti si parla di XML web service).L’obiettivo di questi servizi è quello di fornire alle applicazioni client un’opportuna interfaccia RPC (Remote Procedure Call) per richiamare metodi lato server.

Chiaramente la conoscenza approfondita e l’uso delle tecnologie suddette richiederebbe molto studio ma, come spesso capita, la maggior parte del lavoro necessario alla definizione di un servizio viene svolta da .NET e Visual Studio 2012.

Una cosa importantissima è che l’applicazione che utilizza un determinato servizio ed il servizio stesso non necessitano di conoscere reciprocamente i dettagli implementativi o la piattaforma che utilizza l’altra parte. Un servizio web può essere creato utilizzando qualsiasi linguaggio compatibile con l’architettura SOAP.

Il protocollo SOAP è una parte fondamentale del processo perché esso è responsabile trasmettere i messaggi RPC dai client ai server e di restituire i risultati ai client. SOAP si basa sul linguaggio XML ed è supportato da tutte le piattaforme e gli ambienti di sviluppo, tra cui ovviamente Visual Studio 2012.

In particolare i componenti fondamentali per l’implementazione e l’utilizzo dei servizi web sono fondamentalmente tre: il servizio lato server, l’applicazione client che utilizza il servizio e il linguaggio WSDL per la descrizione delle funzionalità del servizio.

WSDL è uno standard relativamente nuovo utilizzato per descrivere le caratteristiche dei servizi ed il modo in cui essi dovrebbero essere utilizzati. WSDL descrive in un documento XML i metodi del servizio e gli indirizzi tramite cui accedere ad esso.

Le applicazioni client possono essere di vario tipo (ad esempio, Windows Form o applicazioni ASP.NET) e dopo aver impostato un riferimento al servizio esse semplicemente possono utilizzare i metodi esposti dallo stesso.

In caso di servizi web la chiamata ad un metodo in realtà è indirizzata ad un oggetto proxy, il quale a sua volta invoca il servizio remoto. La classe proxy contiene tutta la logica che supporta le chiamate SOAP e legge il file WSDL per verificare se le definizioni dei metodi e le informazioni sui tipi siano corretti prima di attivare tutto il processo. Effettuate queste verifiche il proxy effettua la chiamata HTTP ed invia i pacchetti SOAP al server web.

Sul lato server l’entità del .NET Framework che gestisce queste richieste SOAP le inoltra al servizio per essere processate e alla fine del processo invia una risposta SOAP contenente i risultati dell’elaborazione, tramite la connessione HTTP, al proxy del client. A questo punto il proxy estrae il contenuto di tale risposta e ritorna i valori all’applicazione client.

A partire dalla versione 3.0 del .NET Framework è stato introdotto un pacchetto di sviluppo per applicazioni (in inglese SDK, Software Development Kit), denominato WCF (Windows Communication Foundation), progettato specificatamente per sviluppare applicazioni orientate ai servizi.

Come già accennato, i client ed i servizi interagiscono inviandosi messaggi e in WCF tutti i messaggi sono di tipo SOAP. I messaggi sono indipendenti dai protocolli di trasporto e, a differenza dei classici servizi web, i servizi WCF possono comunicare attraverso vari protocolli di trasporto e non soltanto HTTP. Una cosa molto importante è che i client WCF possono interagire con servizi non di tipo WCF e viceversa.

Con WCF ogni servizio viene associato ad un indirizzo univoco. Tale indirizzo fornisce indicazioni su due importanti elementi: la posizione del servizio ed il protocollo di trasporto utilizzato per la comunicazione.

Gli indirizzi supportano diversi protocolli di trasporto tra cui:

• HTTP
• TCP
• IPC
• MSMQ

e hanno il seguente formato

[protocollo]://[nomemacchina o dominio][:porta opzionale]/[nomeservizio]

Ad esempio un indirizzo su una macchina locale potrebbe essere

http://localhost:8001/ServizioTest

Esso indica che sulla macchina chiamata localhost, utilizzando il protocollo HTTP, un servizio denominato ServizioTest è disponibile ad essere utilizzato tramite la porta 8001.

In WCF tutti i servizi espongono i cosiddetti contratti. Un contratto è una modalità standard ed indipendente dalla piattaforma utilizzata, di descrivere cosa fa un determinato servizio.

E’ possibile distinguere quattro tipi di contratto:

Service Contract – Descrive le operazioni che il client può effettuare sul servizio

Data Contract – Definisce quali tipi dati devono essere passati al servizio e quali restituirà lo stesso

Fault Contract – Definisce quali errori vengono rilevati dal servizio e come il servizio li gestisca e li notifichi al client

Message Contract – Permette al servizio di interagire direttamente tramite messaggi

Segue un esempio di definizione di un service contract:

[ServiceContract]
interface IContrattoTest
{
  [OperationContract]
  string Metodo1(string text);

  string Metodo2(string text);
}
class ServizioTest: IContrattoTest
{
  public string Metodo1(string testo)
  {
    return "Saluti" + testo;
  }
  public string Metodo2(string testo)
  {
    return "Non è possible chiamare tale metodo tramite WCF";
  }
}

Come potete notare nella definizione dell’interfaccia IContrattoTest ho messo l’attributo [OperationContract] solo prima del Metodo1. Ciò comporta che soltanto questo metodo verrà esposto dal servizio, mentre il Metodo2 non sarà accessibile da eventuali client.

Chiaramente ogni servizio deve essere esposto da un processo Windows chiamato processo host. Un singolo processo host può esporre più servizi e lo stesso servizio può essere esposto da più processi host. Il ruolo di host può essere svolto da diverse entità come Internet Information Services (IIS) e Windows Activation Service (WAS), ma anche da applicazioni sviluppate ad hoc.

L’host espone il servizio attraverso quello che viene definito Endpoint

Endpoint = Address + Binding + Contract

Cosa siano i contratti già l’abbiamo visto, gli altri due elementi che costituiscono un endpoint sono:

Binding ‐ E’ costituito da più elementi (detti binding elements) che rappresentano il tipo di trasporto utilizzato (ad esempio TCP), più altre funzionalità più specifiche.

Address ‐ E’ l’indirizzo condiviso tra client e server per la comunicazione

Definire ed utilizzare un servizio WCF

Andiamo adesso ad analizzare in dettaglio i passi da seguire per creare ed utilizzare un servizio utilizzando Visual Studio 2012 e C#. Dopo aver avviato Visual Studio 2012 dal menù File scegliete New -> Project e nella finestra di dialogo New Project selezionate come tipo di progetto WCF e come template WCF Service Library

diamo al servizio il nome ServizioTest ed indichiamo dove salvarlo. Nella finestra Solution Explorer dovremmo visualizzare quanto segue

Supponiamo di voler esporre il nostro servizio tramite IIS. Per fare questo occorre creare all’interno della soluzione corrente un nuovo sito web vuoto, selezionando dal menù File l’opzione Add -> New Web Site

impostiamo come percorso

http://localhost/SitoTest e confermiamo.

Adesso occorre aggiungere al sito un riferimento al nostro servizio ServizioTest e per fare ciò clicchiamo con il tasto destro del mouse sul sito, scegliamo dal menù l’opzione Add Reference

e aggiungiamo il riferimento al servizio tramite la seguente finestra

A questo punto occorre aggiungere al sito web un file di testo ServizioTest.svc con il seguente contenuto

<% @ ServiceHost Language = "C#" Debug = "true" Service = "ServizioTest.Service1"%>

e copiare nel file web.config del sito il contenuto del file app.config del servizio.

Ora si può testare il servizio web, basta aprire un browser e immettere il seguente indirizzo

http://localhost/SitoTest/ServizioTest.svc

Comparirà una pagina WSDL che descrive il nostro servizio.

Prima di proseguire definiamo all’interno del nostro servizio un semplice metodo che richiameremo da un’applicazione client che svilupperemo in seguito.

Per fare questo nel file IService1.cs (generato automaticamente da Visual Studio 2012 quando abbiamo creato il servizio) inseriamo il seguente codice

[ServiceContract]
public interface IService1
{
  [OperationContract]
  string Salutami(string nome);
}

e nel file Service1.cs (anche questo generato automaticamente da Visual Studio)

public string Salutami(string nome)
{
  return string.Format("Salve" + nome);
}

In pratica il file IService1 è l’interfaccia che espone i metodi, mentre il file Service1 contiene l’implementazione degli stessi. Il metodo Salutami semplicemente riceve in input una stringa e restituisce la stringa 'Salve ‘ seguita dal nome passato come input.

Per testare il servizio creiamo una semplice applicazione Windows Form, contenente due caselle di testo (textbox1 e textbox2) e un pulsante (button1).

A questo punto nella finestra Solution Explorer clicchiamo con il tasto destro del mouse sulla nostra applicazione e tra le opzioni del menù contestuale scegliamo Add Service Reference

Si aprirà una finestra in cui impostare l’indirizzo del servizio

Dopo aver effettuato le suddette operazioni basterà scrivere nell’evento Click del pulsante button1 il seguente codice

private void button1_Click(object sender, EventArgs e)
{
  RiferimentoServizio rif = new RiferimentoServizio();
  textBox2.Text = rif.Salutami(textBox1.Text);
}

Il risultato sarà il seguente

Il form richiama il metodo Salutami del nostro servizio, gli passa la stringa Amico ed il servizio restituisce all’applicazione client il risultato dell’elaborazione che viene mostrato nel textbox2.

Chiaramente si tratta di un’applicazione che non ha alcuna utilità pratica ma che lascia intuire le varie operazioni che potenzialmente è possibile effettuare tramite un servizio.

Distribuzione di applicazioni

La distribuzione è il processo mediante cui le applicazioni sviluppate vengono installate su sistemi client. Tipicamente questa attività avviene utilizzando un programma di installazione (Setup Program).

Esistono diverse modalità di installazione di applicazioni ed i più diffusi sono: ClickOnce e Microsoft Windows Installer. Nel presente articolo verranno analizzate le caratteristiche del primo dei due e verrà mostrato come realizzarlo tramite Visual Studio 2012.

Con l’utilizzo di ClickOnce non è necessario avviare un programma di installazione sul sistema client, è sufficiente che gli utenti del sistema clicchino su un link. Un’installazione di tipo ClickOnce può essere effettuata tramite un sito web, una cartella condivisa su una rete locale, ma anche tramite supporti come cd e dvd.

La distribuzione con ClickOnce si basa sui cosiddetti file manifest. Il file application manifest descrive l’applicazione ed i permessi necessari, mentre il file deployment manifest descrive la configurazione di distribuzione. Per distribuire in rete un’applicazione chiaramente questi file devono avere un certificato associato, affinchè l’utente che desidera installare l’applicazione possa conoscere la sua provenienza.

Vediamo adesso come effettuare la distribuzione di un’applicazione con ClickOnce. Apriamo un progetto di un’applicazione Windows Form in Visual Studio 2012 e nella finestra Solution Explorer facciamo doppio click sul nodo Properties. Si aprirà la pagina delle propietà del progetto e in essa selezioniamo la tab Signing

Spuntiamo il checkbox Sign the ClickOnce manifests

e successivamente clicchiamo sul pulsante Create Test Certificate per creare un certificato di test da associare ai file manifest. Dopo aver cliccato sul pulsante ci viene richiesto di inserire una password. Inseriamola e annotiamola da qualche parte perché essa servirà in seguito

Il certificato serve a fare in modo che l’utente che si accinge ad installare l’applicazione possa identificare il creatore della stessa e la sua origine in modo da poter decidere se proseguire con l’installazione o annullare il processo. Chiaramente con il certificato di prova che abbiamo appena creato l’utente non si troverà nelle condizioni di ricevere informazioni affidabili e riceverà un messaggio di avvertimento sulla scarsa affidabilità delle informazioni contenute in esso, cioè le seguenti

Il certificato di prova ci serve solo come esempio e prima di una eventuale distribuzione di un’applicazione è necessario ottenere un certificato reale da un’autorità di certificazione legalmente riconosciuta. Se l’applicazione viene distribuita soltanto all’interno di una intranet è possibile ottenere i certificati da un server locale di certificazione, se nella rete locale ne è installato uno.

Avendo a disposizione un certificato reale potete configurarlo cliccando sul pulsante Select from file, sempre nella tab Signing.

Il passo successivo alla configurazione del certificato è quello di definire i requisiti di sicurezza dell’applicazione. Per fare ciò nella finestra Properties del progetto selezioniamo la tab Security, spuntiamo l’opzione Enable ClickOnce Security Settings, clicchiamo sul radiobutton This is a partial trust application e selezioniamo il valore Custom per l’opzione Zone your application will be installed from (indica da dove verrà installata l’applicazione)

La sicurezza è un aspetto fondamentale delle applicazioni .NET. Tutto il codice dell’applicazione viene analizzato per individuare i permessi richiesti. Il risultato di tale operazione è un file app.manifest (visibile nella finestra Solution Explorer) che contiene le indicazioni su tali requisiti di sicurezza.

Un esempio potrebbe essere il seguente

<?xml version="1.0" encoding="utf-8"?>
<asmv1:assembly manifestVersion="1.0" 
xmlns="urn:schemas-microsoft-com:asm.v1" 
xmlns:asmv1="urn:schemas-microsoft-com:asm.v1" 
xmlns:asmv2="urn:schemas-microsoft-com:asm.v2" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<assemblyIdentity version="1.0.0.0" 
name="MyApplication.app" />
  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v2">
    <security>
      <requestedPrivileges xmlns="urn:schemas-microsoft-com:asm.v3">
        <requestedExecutionLevel level="asInvoker" uiAccess="false" />
      </requestedPrivileges>

      <applicationRequestMinimum>
        <defaultAssemblyRequest permissionSetReference="Custom" />
        <PermissionSet class="System.Security.PermissionSet" version="1" ID="Custom" SameSite="site">
        <IPermission class="System.Security.Permissions.ReflectionPermission, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true" />
        <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="UnmanagedCode, Execution, ControlEvidence" />
        <IPermission class="System.Security.Permissions.UIPermission, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Window="SafeSubWindows" Clipboard="OwnClipboard" />
        </PermissionSet>
      </applicationRequestMinimum>

    </security>
  </trustInfo>
</asmv1:assembly>

Come potete osservare, si tratta di un file XML e l’elemento applicationRequestMinimum definisce tutti i permessi richiesti dall’applicazione.

Dopo avere definito i requisiti di sicurezza possiamo passare alla pubblicazione (Publishing) della stessa attraverso la creazione del file deployment manifest. Questa operazione può essere eseguita molto semplicemente tramite la procedura guidata Publish Wizard.

Per avviare tale procedura clicchiamo sul menù Build e selezioniamo l’opzione Publish ApplicazioneTest (dove ApplicazioneTest è il nome dell’applicazione)

Nella prima finestra del wizard inseriamo il percorso in cui pubblicare l’applicazione e proseguiamo

Nella seconda schermata selezioniamo la prima opzione e andiamo avanti

l’ultima schermata riporta soltanto un riepilogo, in essa clicchiamo su Finish.

In pratica questa procedura crea un sito web sull’IIS locale, come se fosse un server web. I file dell’applicazione, i file manifest, un file setup.exe ed una pagina publish.htm vengono copiati su tale server

A questo punto aprendo la pagina publish.htm (presente nella cartella dell’applicazione) comparirà una pagina simile alla seguente, tramite la quale è possibile effettuare l’installazione dell’applicazione