Corso C# – Lezione n.3

Il linguaggio C# sviluppato da Microsoft oggi aperto e multi piattaforma consente di scrivere programmi, applicazioni web e librerie di ogni genere con moderne tecniche di programmazione. In questa lezione sono introdotte le classi cardine dei principi della programmazione ad oggetti, e l’uso di classi già disponibili come la classe List della Collection.Generic per aggregare in modo veloce ed efficiente gli oggetti e quindi grandi quantità di informazioni. Questo è solo il preludio all’introduzione nelle lezioni dalla quinta alla dieci di tecniche di memorizzazione persistente sui memoria di massa e altra tipologia di storage connesso.

Argomenti

La classe

La classe è per definizione un’entità astratta della realtà che si intende rappresentare nel programma che deve gestirla per svolgere l’attività richiesta dal problema.
Ad esempio una classe “Persona” può rappresentare l’insieme dei dati anagrafici di una persona qualunque che possono poi eventualmente letti o scritti da altre classi o dal programma.
La classe quindi è definita da un nome rappresenta l’insieme di tutti gli elementi che sono caratterizzati da caratteristiche in comune.
Nel caso della classe “Persona” l’insieme di tutte le persone che hanno delle caratteristiche in comune ad esempio “essere maggiorenni”, “essere lavoratori”, e così via.
Ogni classe si caratterizza da un certo numero di membri che sono differenziati in due tipologie. La prima tipologia sono gli attributi ovvero l’insieme dei dati che quella classe deve gestore. la seconda tipologia sono i metodi ovvero le funzionalità che permettono di leggere e scrivere gli attributi della classe stessa. Nell’ambito di un programma la classe rappresenta in modo generico l’insieme ti tutti gli elementi che si intende gestire nel programma.
Nel programma la classe diventa operativa, quando viene definito uno o più elementi specifici della stesa detti “Oggetti”. Un oggetto rappresenta un elemento della classe che possiede tutti gli attributi impostati a valori specifici durante l’operazione di istanziamento.
In altri termine classe “Persona” , è l’insieme di tutte le persone mentre l’oggetto P di tipo Persona potrebbe essere il Sig.r “Rossi Mario, nato a Roma il 20/03/1995”.
Quindi concretamente nel programma sono gestiti oggetti di una o più classi che concorrono alla soluzione del problema secondo quelli che sono i requisiti richiesti dal progetto software.

La rappresentazione UML di un classe

Per rappresentare una classe utilizza il linguaggio grafico UML che rappresenta mediante un opportuno schema.
Lo schema UML prevede la definizione del “diagramma della classe” un rettangolo diviso in tre aree nlla prte superior il titolo della classe, nella parte centrale gli attributi della classe, e nell’area inferiore i metodi della classe. E’ utilizzata per ogni membro la notazione “+”per dire che il membro è pubblico quindi accessibile da ogni classe anche di assembly diversi, il segno “-” indica che il membro è privato ovvero accessibile solo dai metodi della classe stesa, il segno “#” indica che il membro è protetto ovvero che è accessibile da altre classi dello stesos assembly.
L’assembly in C# è l’equivalente del package in java ovvero l’insieme delle classi che svolgono determinate funzionalità. Di norma in C# gli assembly sono richiamati mediante la clausola “Using nome assemblly.*;” per richiamare tutte le classi o “Using nome assembly.nome classe;”:
Per chiarire meglio i concetti introduciamo un esempio ovvero la classe “ContoCorrente” che in UML è quindi rappresentata dalla figura sotto riportata.

Rappresentazione della classe "conto Corrente" in UML sono inseriti i membri intestazione stringa, il saldo numero reale, la data_saldo come data, la variabile rosso che indica se il saldo è zero o negativo, e il numero di conto che è stringa.
Sono definiti quattro metodi uno per il versamento, uno per la visualizzazione del saldo, uno per il prelevamento e uno per verificare se il conto specifico è a rosso.

Nel diagramma UML gli attributi intestazione, saldo, data, rosso, numero conto sono privati. Nel diagramma UML sono specificati anche la tipologia dei dati degli attributi ma anche dei parametri dei metodi e gli eventuali valori di ritorno.

Struttura di una classe: attributi e metodi

In generale la struttura di una classe in C# è del tipo:
[modificatore accesso] class nome classe
{
[modificatore di accesso] tipo1 attributo 1;
[modificatore di accesso] tipo 2 attributo 2;

[modificatore di accesso] tipo N attributo N;
[modificatore ] [tipo 1 / void ]metodo 1([elenco di parametri]);
[modificatore ] [tipo 2 / void ]metodo 2([elenco di parametri]);
..
[modificatore ] [tipo N / void ]metodo N([elenco di parametri]);
}

La clausola [modificatore di accesso] prevede: private, public, protected, ovvero che regola di accesso deve avere il membro, i metodi devono essere pubblici per leggere e scrivere attributi della classe che sono dichiarati private da ogni punto del programma o da altre classi o assembly.
Nella definizione del metodo è possibile un ritorno di un tipo specifico oppure, l’uso della clausola void per indicare che il metodo esegue un’elaborazione e non ritorna valore.
Un esempio di classe è “ConcoCorrente” , così strutturata:

Link sposorizzato

 public class ContoCorrente
        {
            string intestazione;
            double saldo;
            Boolean rosso = false;
            DateTime data_saldo = DateTime.Now;
            string numero_conto;
        public ContoCorrente(string intestatazione1, string nconto, double s, DateTime datas)
            {
                intestazione = intestatazione1;
                numero_conto = nconto;
                saldo = s;
                data_saldo = datas;
                 rosso = false;
            }
        public double Saldo
        {
            get; set;
        }
        public string Intestazione
        { get; set; }
        public string Numero_conto
        { get; set; }
        bool Rosso()
        {
            if (saldo<=0)
            {
                rosso = true;
            }
            return rosso;
        }
        public double visualizzasaldo(string nconto)
        {
            if (nconto == numero_conto)
            {
                return saldo;
            }
            else
            {
                Console.WriteLine("\n Numero conto non presente !\n");
                return 0;
            }
        }
        public override string ToString()
        {
             return numero_conto + "--" + intestazione + "--" + saldo + "\n";
           
        }
        public void Versamento(string nconto, double importo)
        {
            if (nconto == numero_conto)
            { saldo = saldo + importo; }
            else
            {
                Console.WriteLine("\n Numero conto non presente !\n");
            } }
       public void Prelevamento(string nconto, double importo)
            {
                if (nconto == numero_conto)
                {
                  if (!Rosso())
                    {
                        if ((saldo-importo>=0))
                        {
                            saldo = saldo - importo;
                        }
                        else
                        {
                            Console.WriteLine("\nImpoorto superiore alla disponibilità !\n");
                        }
                    }
                  else
                    {
                        Console.WriteLine("\n Sei a rosso non puoi prelevare !\n");
                    }
                }
                else
                { Console.WriteLine("\n Numero conto non presente !\n");
                }}
        }

La struttura della classe prevede vari metodi come descritto nel linguaggio UML e in aggiunta le Property e il Costruttore.

Il costruttore della classe e le proprietà get e set

Il costruttore ha il nome della classe e può prevedere dei parametri, è il primo metodo che è eseguito quando è istanziato l’oggetto della classe. E’ detto anche metodo “inizializzatore” poiché permette l’inizializzazione degli attributi della classe, o delle attività da far svolgere al primo istanziamento dell’oggetto.
Nel codice il costruttore è:

public ContoCorrente(string intestatazione1, string nconto, double s, DateTime datas)
            {
                intestazione = intestatazione1;
                numero_conto = nconto;
                saldo = s;
                data_saldo = datas;
                 rosso = false;
            }

Il costruttore inizializza gli attributi che sono impostati ai valore dei parametri in ingresso al costruttore. E’ introdotto il tipo DateTime è un tipo dati che permette di gestire le date e gli orari secondo i più disparati formati.
Inoltre sono definite le Properies in C#, attraverso le parole chiavi get e set permettono di leggere e impostare gli attributi della classe singolarmente. Nel codice sono presenti delle Properties per tutti gli attributi della classe tranne per l’attributo “rosso”.
Ecco il codice:

ublic double Saldo
        {
            get; set;
        }
        public string Intestazione
        { get; set; }
        public string Numero_conto
        { get; set; }

Le proprietà sono impostate a livello di singolo attributo richiamando i nomi delgli attributi con la prima lettera maiuscola.

La classe Collection.Generic e la classe List

La collection è una raccolta di classi di cui fa parte anche la classe Generic che contiene una serie di classi fra cui la List. La Collection è una raggruppamento di classi che è caratterizzata da caratteristiche comuni, prima fra tutte quelle di essere dinamiche e non tipizzate ovvero non essere vincolate ad un particolare tipo di dato.
La List è la classe per gestire una lista di elementi di tipo generico, infatti essa può essere composta da numeri, da stringhe o da oggetti di una classe specifica.
La dichiarazione di una lista avviene con la sintassi:
List<tipo / classe> identificatore;
mentre l’allocazione è attuata con:
identificatore = new List<tipo / classe>();
Ad esempio classe Persona;
List<Persona> classe = new List<Persona>;
definisce una lista di nome “classe”.
Un altro esempio può essere:
List<int> numeri = new List<int>();
definisce una lista di numeri interi.
Alcuni metodi fondamentali per la lista:
metodo Add per aggiungere elemento alla lista, Clear per cancellare tutti gli elementi della Lista, RemoteAt(int 32) rimuove un elemento della lista nella posizione indicata come argomento.
Tutte le proprietà, i costruttori e i metodi per la classe List è sul sito Microsoft qui.
La lista può essere consultata sia con il ciclo foreach che con il ciclo for.
Con il ciclo foreach la struttura è:
foreach (Classe c in identificate lista)
{ codice da eseguire}
mentre con il ciclo for la struttura è:
for (int k=0;k<identificatore_lista.Capacity; k++)
{ per selezionare un elemento identificatore_lista[k];
codice da eseguire nel ciclo
}

Caso di studio

Il progetto prevede la gestione di un insieme di conti correnti mediante l’uso di una Lista che è composta da un insieme di conti correnti.
La spiegazione completa sul video incluso al presente articolo.
Link sponsorizzato

Video