1. Come creare correttamente un oggetto
L'operatore new in C# è come un pulsante magico che trasforma un semplice "progetto" (la nostra classe) in una vera istanza (oggetto) con cui puoi lavorare. In parole povere: la classe definisce cosa può fare l'oggetto e quali proprietà ha, mentre new crea questo oggetto nella memoria del computer.
Senza l'operatore new le nostre classi sarebbero solo dei progetti senza costruzione: puoi guardarli, discuterne, ma non puoi saltarci sopra o rovesciare il tè sulla poltrona in alcantara.
Se la classe è la ricetta della pizza, l'operatore new è il cuoco che, seguendo la ricetta, crea una vera pizza gustosa. L'oggetto è il risultato: la pizza nella scatola, pronta da mangiare.
Sintassi
Vediamo come usare questo potentissimo new. Ecco la sintassi base, se abbiamo una classe Contact:
Contact cont = new Contact();- Contact a sinistra — è il tipo della variabile che stiamo creando.
- cont — il nome della variabile (scegli nomi sensati, se non vuoi impazzire col debug in futuro).
- new Contact() — chiamata dell'operatore new, che crea un oggetto di tipo Contact.
Nella memoria
Quando esegui questo codice, il sistema operativo riserva un pezzetto di memoria per il nuovo oggetto e restituisce un riferimento (indirizzo) dove quell'oggetto "vive". Questo riferimento viene salvato nella variabile cont.
Schema
+------------------+ +--------------------+
| variabile cont | ---------> | Oggetto Contact |
+------------------+ +--------------------+
|
| (contiene nome, telefono, email, ...)
|
indirizzo
2. Creiamo oggetti contatto
Negli esempi precedenti abbiamo inventato questa classe:
public class Contact
{
public string Name;
public string Phone;
public string Email;
}
Ora creiamo un nuovo oggetto di tipo Contact:
Contact friend = new Contact();
friend.Name = "Ivan Ivanov";
friend.Phone = "+1-999-123-45-67";
friend.Email = "ivan@example.com";
Console.WriteLine($"Nome: {friend.Name}, Telefono: {friend.Phone}, Email: {friend.Email}");
Cosa succede qui:
- Creiamo un oggetto con new Contact().
- Assegniamo valori ai suoi campi.
- Stampiamo i dati a schermo.
Esempio 2:
Aggiungiamo la gestione di più contatti — creiamo un altro oggetto:
Contact boss = new Contact();
boss.Name = "Anastasia Sergeevna";
boss.Phone = "+1-888-765-43-21";
boss.Email = "nastya@company.com";
Console.WriteLine($"Boss: {boss.Name}, Telefono: {boss.Phone}");
Non ti ricorda la compilazione di un modulo per ogni conoscente? Proprio così funzionano gli oggetti: ogni istanza creata riceve i suoi valori unici e li conserva separatamente dagli altri!
3. Uso di un array di oggetti
Se dobbiamo conservare non uno o due, ma diciamo dieci contatti, ha senso tenerli in un array:
Contact[] contacts = new Contact[3]; // array per 3 oggetti
contacts[0] = new Contact();
contacts[0].Name = "Denis";
contacts[0].Phone = "+7-911-111-22-33";
contacts[1] = new Contact();
contacts[1].Name = "Maria";
contacts[1].Phone = "+7-915-123-45-67";
contacts[2] = new Contact();
contacts[2].Name = "Pietro";
contacts[2].Phone = "+7-921-543-21-00";
// Stampiamo tutti a schermo
for (int i = 0; i < contacts.Length; i++)
{
Console.WriteLine($"Contatto {i+1}: {contacts[i].Name}, {contacts[i].Phone}");
}
Importante: usiamo new per ogni elemento dell'array! Solo creare l'array non crea gli oggetti stessi, ma prepara solo lo spazio per i riferimenti.
4. Operatore new e valore di default
A volte ci si chiede — e se dichiaro solo una variabile di tipo Contact ma non le assegno un oggetto tramite new, cosa succede?
Contact someContact;
someContact.Name = "Errore"; // Errore di compilazione!
Se invece scrivi:
Contact someContact = null;
allora, se provi ad accedere a someContact.Name, il tuo programma "crasherà" con la famigerata eccezione:
System.NullReferenceException: Il riferimento all'oggetto non punta a un'istanza di oggetto.
Per evitare questo, inizializza sempre gli oggetti con new prima di usarli.
5. Chiamata del costruttore
Quando scrivi new Contact(), in quel momento viene chiamato un metodo speciale — il costruttore. Al momento la nostra classe non contiene costruttori espliciti, quindi viene chiamato il costruttore implicito (di default), che crea l'oggetto e riempie tutti i campi con i valori di default (null per i tipi reference e zero per i numerici).
Nella prossima lezione scoprirai come creare costruttori personalizzati — ad esempio, per passare subito nome e telefono. Per ora funziona solo il costruttore senza parametri.
Esempi dalla vita reale
Lavorare con oggetti tramite l'operatore new è la routine quotidiana di ogni sviluppatore C#. Immagina di:
- Creare un utente su un sito — nel codice appare un nuovo oggetto User.
- Aprire un ordine in un e-commerce — appare un nuovo Order.
- Inserire dati di un libro — nuovo oggetto Book.
In qualsiasi programma moderno in C# troverai migliaia di righe con l'operatore new.
Memoria prima della creazione dell'oggetto
Contact firstContact; // Variabile, ma non punta a nulla+--------------------------+
| firstContact |----> null (niente!)
+--------------------------+
Dopo la creazione dell'oggetto
Contact firstContact = new Contact();+--------------------------+ +----------------------+
| firstContact |---------------->| Oggetto Contact |
+--------------------------+ +----------------------+
6. Esempio pratico
Supponiamo di voler permettere all'utente di creare nuovi contatti tramite input da tastiera:
Console.WriteLine("Inserisci il nome:");
string name = Console.ReadLine();
Console.WriteLine("Inserisci il telefono:");
string phone = Console.ReadLine();
Contact newContact = new Contact();
newContact.Name = name;
newContact.Phone = phone;
Console.WriteLine($"Contatto salvato: {newContact.Name}, {newContact.Phone}");Ora ogni input dell'utente creerà il suo oggetto unico in memoria, che puoi salvare, modificare, stampare — farci quello che vuoi!
7. Errori tipici e trappole divertenti
Errore n°1: hai dimenticato di chiamare new prima di lavorare con l'oggetto.
Se dichiari una variabile ma non la inizializzi, rischi di beccarti un errore di compilazione o una NullReferenceException a runtime. È un classico: dichiari un oggetto — crealo subito con new se ti serve davvero.
Errore n°2: hai creato un array di oggetti, ma non gli oggetti stessi.
Ecco una trappola comune: crei un array di tipo Contact[], ma dimentichi che dentro ci sono solo null. Se provi ad accedere a contacts[0].Name il programma va giù. Prima devi inizializzare ogni elemento dell'array: contacts[i] = new Contact();.
Errore n°3: hai confuso un metodo con una proprietà.
A volte i principianti pensano che un metodo si possa usare come un campo: scrivono student.GetName invece di student.GetName(). Funziona finché non provi a usare subito il risultato — ma il compilatore si lamenterà se provi a mettere il "metodo" dove serve un valore. Ricorda: il metodo va chiamato con le parentesi tonde, anche se non prende parametri.
GO TO FULL VERSION