Il class diagram di Visual Studio 2005

1. Introduzione

Credo che alla base di un ogni buon progetto ci sia la progettazione, soprattutto la progettazione delle classi e delle entità che compongono il progetto. In particolare in un progetto con più strati, il layer di business dove sono rappresentate le entità coinvolte debba essere progettato al meglio.

Nel nuovo IDE di sviluppo Visual Studio 2005 è stato introdotto un nuovo oggetto il Class Diagram che ci permette di progettare in maniera visuale le nostre classi mettendoci a disposizione diversi strumenti che aumentano la produttività scrivendo meno codice a mano.

2. Con Visual Studio 2003 cosa usavamo?

Fino ad oggi, per progettare le nostre classi, per avere una forte tipizzazione o si usava Visio o altri tool simili che utilizzando UML ci permettevano di creare il disegno delle nostre classi e poi creare i file del progetto con estensione .cs(per c#) .vb(per visual basic.net).
Però spesso questo non era il massimo della produttività primo perché sia visio che gli altri strumenti non parlavamo correttamente con Visual Studio, secondo se avevamo creato dei nostri oggetti chiaramente questi non ero visto e quindi c’erano diverse limitazioni che spesso ci hanno portato a non usare questi prodotti.

3. Ora con Visual Studio 2005

La prima cosa importante è che il Class Diagram è un’item all’interno di Visual Studio 2005 e che non viene fatto alcun revers engineering ma il file che viene creato è solo una rappresentazione visuale della nostra classe.

Per cominciare come prima dobbiamo aggiungere un nuovo class diagram:
quindi dal nostro progetto facciamo tasto destro --> Add New Item --> scegliamo Class Diagram

Il Class Diagram ha un’estensione .cd.
Dopo che aggiungiamo un nuovo class diagram viene visualizzata la casella degli strumenti così fatta

Come potete vedere possiamo creare vari oggetti:
• Classe
• Enumerazione
• Interfaccia
• Classe Astratta
• Struttura
• Delegato
In un Class Diagram possiamo inserire tutte questi oggetti anche insieme senza nessun limite, anzi è buon norma creare un Class Diagram per tutte le entità correlate tra di loro.

Andiamo a creare una nuova classe:
Tramite il drag&drop trascino la classe sul piano di disegno e appare questa finestra

Dopo dobbiamo definire:
• Il nome della classe, nel nostro caso Customer
• Il tipo di Accesso, Pubblico, Internal o Default che in vs 2005 è private
• Poi se vogliamo che creare un nuovo file o aggiungere da uno esistente

Una volta che si da ok in automatico viene creato un nuovo file Customer.cs
Poi andiamo a creare/progettare la nostra entita customer utilizzando il Class Details, se non è visibile cliccare con il tasto destro sull’entità e poi Class Details

Per prima cosa inseriamo i nostri fields

Come potete vedere possiamo inserire il nome, il tipo, l’accesso e anche inserire il Summary che server per i commenti xml che vengono inseriti in automatico.

Poi per creare delle proprietà partendo dai campi usiamo una nuova funzionalità di Visual Studio che è il Refactor.
Quindi cliccando su ogni campo facciamo tasto destro --> Refactor --> Encapusalete Field:
verrà visualizzata una finestra che ci chiede come voler creare questa proprietà

Quest’ultima operazione può essere fatta anche direttamente sul codice
Il refactoring è un processo molto potente che permette di aggiornare il proprio codice senza dover ritoccare i progetti su quale viene referenziato.
Dopo aver incapsulato tutti i campi la nostra classe si presenterà così

E in automatico il nostro file Customer.cs senza aver fatto nulla avrà questa struttura

Codice .NET n°1

public class Customer
    {
        /// <summary>
        /// </summary>
        private Int32 _idCustomer;

        /// <summary>
        /// identificativo del cliente
        /// </summary>
        public Int32 IdCustomer
        {
            get { return _idCustomer; }
            set { _idCustomer = value; }
        }
        /// <summary>
        /// </summary>
        private string _name;

        /// <summary>
        /// ragione sociale
        /// </summary>
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        /// <summary>
        /// </summary>
        private string _city;

        /// <summary>
        /// citta del cliente
        /// </summary>
        public string City
        {
            get { return _city; }
            set { _city = value; }
        }
        /// <summary>
        /// </summary>
        private string _address;

        /// <summary>
        /// indirizzo del cliente
        /// </summary>
        public string Address
        {
            get { return _address; }
            set { _address = value; }
        }
        /// <summary>
        /// </summary>
        private DateTime _dateIn;

        /// <summary>
        /// data di ingresso
        /// </summary>
        public DateTime DateIn
        {
            get { return _dateIn; }
            set { _dateIn = value; }
        }
        /// <summary>
        /// </summary>
        private DateTime _dateOut;

        /// <summary>
        /// data di uscita
        /// </summary>
        public DateTime DateOut
        {
            get { return _dateOut; }
            set { _dateOut = value; }
        }
    }

Poi se vogliamo inserire un costruttore ci basta fare cliccare con il tasto destro sull’oggetto e fare come mostrato in immagine

Se poi vogliamo inserire dei parametri o aggiungere un nuovo metodo lo possiamo fare sempre usando il Class Details, cliccando rispettivamente su e

4. Interfaccie

Molto interessante è anche come creare le interfaccie e come si possono implementare.
Come per la classe inseriamo l’oggetto interface tramite il drag&drop e creiamo una nuova interfaccia chiamata IOrders che avrà la seguente struttura

Se poi vogliamo implementare questa interfaccia creiamo una nuova classe Orders e usiamo l’oggetto Inheritance cliccando prima sulla classe Orders e poi trascinando sull’interfaccia

Una volta rilasciato il mouse la classe Orders implementerà l’interfaccia IOrders e avrà questa struttura

E in automatico la classe Orders.cs avrà tutte le proprietà che chiaramente dovranno essere implementate.

5. Associazioni

Si può anche associare una classe ad un'altra in modo che la classe abbia come proprietà un’istanza della classe associata, questo si può fare tramite l’oggetto Association

In questo modo nella classe Orders viene creata una proprietà di tipo Customer

Codice .NET n°2

public Customer Customer
 {
            get
            {
                throw new System.NotImplementedException();
            }
            set
            {
            }
}

La cosa davvero interessante è che se viene fatta una modifica nei file .cs(o .vb) in automatico viene riporta sul class diagram.

Conclusioni

Il class diagram è novità davvero interessante e piacevole soprattutto per chi ricopre un ruolo di progettista dovendo creare le entità “importanti” del progetto, ma anche per tutti gli sviluppatori potendo creare in modo visuale e sicuramente meglio le classi. Importante è che class diagram e classe sono tutto uno, infatti dove viene un cambiamento in automatico è riportato.