1. Il programma — come un ufficio pieno di reparti
Quando inizi a conoscere la programmazione, sembra che puoi semplicemente scrivere codice riga dopo riga e tutto funzionerà. Ma appena il programma si complica un po', inizia la confusione: dove si trova cosa, perché è stato scritto, e se devi cambiare una riga — dove si trova esattamente?..
Per questo C#, come la maggior parte dei linguaggi moderni, ci offre un modo per “mettere in ordine” il codice, così che in ogni momento puoi capire cosa fa il programma e trovare velocemente il punto giusto.
Immagina un'azienda. Ci sono le risorse umane, la contabilità, il reparto IT, la logistica e così via. Ogni reparto ha la sua area di responsabilità, i suoi dipendenti e i suoi compiti.
In un programma in C# ogni “reparto” è una classe. Una classe si occupa, per esempio, di lavorare con gli utenti, un'altra dei calcoli, un'altra ancora della gestione dei file.
Ecco una struttura tipica di un progetto semplice:
- Program.cs — l'ufficio principale: qui c'è il “punto di ingresso”, da dove tutto inizia.
- User.cs — il reparto dove vengono conservati e gestiti i dati dell'utente.
- Calculator.cs — il reparto dei calcoli.
- FileHelper.cs — gli specialisti dei file.
Anche in un programma molto piccolo di solito c'è almeno una classe. E i progetti grandi sono già un vero “grattacielo” di centinaia di classi!
2. La classe — una scatola di attrezzi
C# è un linguaggio orientato agli oggetti e tutto in esso è un oggetto. I tipi di oggetti si chiamano classi.
Una classe è come una scatola o un armadietto dove mettiamo le cose che ci servono: variabili, metodi, proprietà. Immagina una scatola con scritto “Martelli”: dentro ci sono solo strumenti legati ai martelli.
class Example
{
// Qui ci saranno i nostri attrezzi: variabili, metodi, proprietà
}Le classi di solito contengono variabili e funzioni. In C# le variabili di una classe si chiamano campi, mentre le funzioni della classe sono i metodi. Ma il senso non cambia.
Ti ricordi il nostro primo codice?
Console.WriteLine("Ciao a tutti!");
string name = Console.ReadLine();
In questo codice ci sono sia una classe che dei metodi:
- Console — è una classe che contiene metodi (funzioni) per lavorare con la console.
- WriteLine — è un metodo della classe Console che stampa testo a schermo.
- ReadLine — è un metodo della classe Console che legge l'input da tastiera.
Tutta la programmazione, in un certo senso, si riduce a scrivere le proprie classi e metodi, che chiamano i metodi di altre classi.
3. I campi (variabili) della classe — la sua memoria
Dentro una classe puoi conservare variabili (spesso chiamate “campi”). Sono come celle di memoria dove mettiamo dei dati.
class Counter
{
int value; // campo — qui verrà salvato il valore attuale del contatore Counter
}I campi permettono alla classe di ricordare qualcosa tra una chiamata e l'altra dei vari metodi. Per esempio, contare quante volte è stato premuto un pulsante.
Puoi avere tutti i campi che vuoi. Esempio:
class User
{
int id; // numero unico dell'utente
string name; // nome dell'utente
int age; // età
string adress; // indirizzo
User[] children; // figli
}
4. I metodi — le azioni che può fare la classe
I metodi sono le “abilità” della nostra classe. Se la classe è un dipendente, i metodi sono le sue skill: quello che sa fare.
- Un metodo può stampare qualcosa a schermo.
- Calcolare la somma di due numeri.
- Ricevere dati “in input” e restituire un risultato.
Struttura di un metodo:
- Tipo di valore restituito (per esempio, void — se non restituisce nulla, oppure int — se restituisce un numero)
- Nome del metodo (per esempio, Print)
- Parametri tra parentesi (possono anche essere vuoti)
- Graffe { ... } — il corpo del metodo
class Printer
{
public void PrintHello()
{
Console.WriteLine("Ciao!");
}
public int Add(int a, int b)
{
return a + b;
}
}Scoprirai di più sui metodi e su tutti i dettagli nelle prossime lezioni.
5. Proprietà — variabili intelligenti
Una proprietà (property) è come una variabile “potenziata”: non solo conserva un valore, ma può anche fare qualcosa quando il valore viene letto o cambiato.
Esempio dalla vita reale: non puoi semplicemente cambiare lo stipendio di un dipendente — il contabile controllerà che sia tutto ok. Così anche una proprietà può “controllare” i dati:
class Person
{
private int age; // variabile (campo) della classe
public int Age // proprietà Age. salva i dati nella variabile della classe age.
{
get { return age; } // metodo get - viene chiamato quando qualcuno prova a leggere Age
set // metodo set - viene chiamato quando qualcuno prova a cambiare Age
{
if (value >= 0)
age = value;
}
}
}
Il codice nel metodo set non permette di impostare un'età negativa. Vedremo le proprietà più in dettaglio nelle prossime lezioni.
6. Modificatori di accesso
In C# puoi decidere quali parti di una classe sono accessibili da altre classi e quali restano solo per uso interno. Per questo si usano i modificatori di accesso. Se davanti al nome di un campo, metodo o classe c'è la parola chiave public, puoi accedervi da qualsiasi punto del programma.
Se invece davanti al nome di un campo, metodo o classe c'è la parola chiave private, puoi accedervi solo dalla stessa classe. Le altre classi non vedranno quel campo o metodo. Come se non esistessero proprio.
- public — visibile a tutti. Questi metodi e proprietà possono essere usati da altre classi.
- private — visibile solo dentro la stessa classe. Sono dettagli interni che non dovrebbero essere accessibili agli altri.
class Demo
{
public int OpenValue; // visibile dall'esterno
private int secretValue; // visibile solo all'interno
public void ShowOpen() { Console.WriteLine(OpenValue); }
private void HideSecret() { Console.WriteLine(secretValue); }
}
Regola d'oro: i campi di solito si fanno private, e si rendono “pubblici” solo i metodi e le proprietà necessari (public).
7. Come appare una classe reale
Ecco un esempio “assemblato” — mini-calcolatrice:
class Calculator
{
private int result; // campo per salvare il risultato
public int Result
{
get { return result; }
private set { result = value; } // accessibile solo dentro la classe
}
public void Add(int a, int b)
{
result = a + b;
}
public void Clear()
{
result = 0;
}
}
Questo approccio si trova praticamente in tutti i programmi C# moderni!
8. Top-level statements
In realtà in C# tutto il codice si trova sempre dentro le classi. La classe è l'unità minima di un programma. In un programma possono esserci molte classi, ma almeno una ci deve essere.
Aspetta un attimo, e tutto quel codice che abbiamo appena scritto, lì non c'erano classi?!
Questa è una delle novità di C#: puoi scrivere codice senza classe, e il compilatore C# lo trasformerà automaticamente in una classe.
Supponiamo che tu abbia questo codice in Program.cs:
// il tuo codice
WriteSmile();
WriteSmile();
WriteSmile();
//la tua funzione personale
void WriteSmile()
{
Console.WriteLine(":)");
}Il compilatore C# lo trasforma così:
using System;
class Program
{
static void Main() // il tuo codice
{
WriteSmile();
WriteSmile();
WriteSmile();
}
static void WriteSmile() //la tua funzione personale
{
Console.WriteLine(":)");
}
}Se hai capito solo metà della lezione, non preoccuparti: l'importante è cogliere il senso. Nelle prossime lezioni vedremo passo passo tutto quello che è stato scritto qui.
GO TO FULL VERSION