Classi (Guida per programmatori C#)

Articolo
09/12/2008

Aggiornamento: Luglio 2008

Una classe è un costrutto che consente di creare tipi personalizzati raggruppando insieme variabili di altri tipi, metodi ed eventi. Una classe è simile a un progetto iniziale. Definisce i dati e il comportamento di un tipo. Se la classe non è dichiarata come statica, il codice client può utilizzarla creando oggetti o istanze assegnati a una variabile. La variabile rimane in memoria finché tutti i riferimenti ad essa non escono dall'ambito. In quel momento, CLR la contrassegna come idonea per la procedura di garbage collection. Se la classe è dichiarata come statica, in memoria ne esiste una sola copia accessibile dal codice client solo tramite la classe stessa, non una variabile dell'istanza. Per ulteriori informazioni, vedere Classi statiche e membri di classi statiche (Guida per programmatori C#).

A differenza delle strutture, le classi supportano l'ereditarietà, una caratteristica fondamentale della programmazione orientata a oggetti. Per ulteriori informazioni, vedere Ereditarietà (Guida per programmatori C#).

Dichiarazioni di classi

Le classi vengono dichiarate utilizzando la parola chiave class, come illustrato nell'esempio seguente:

public class Customer
{
    //Fields, properties, methods and events go here...
}

La parola chiave class è preceduta dal livello di accesso. Poiché in questo caso viene utilizzato public, qualsiasi utente può creare oggetti da questa classe. Il nome della classe segue la parola chiave class. Il resto della definizione è costituito dal corpo della classe, in cui vengono definiti il comportamento e i dati. I campi, le proprietà, i metodi e gli eventi di una classe vengono collettivamente definiti membri della classe.

Creazione di oggetti

Anche se a volte vengono utilizzati in modo interscambiabile, classi e oggetti sono differenti. Una classe definisce un tipo di oggetto, ma non l'oggetto stesso. Un oggetto è un'entità concreta basata su una classe e viene a volte definito istanza di una classe.

Gli oggetti possono essere creati utilizzando la parola chiave new seguita dal nome della classe su cui sarà basato l'oggetto, come illustrato di seguito:

Customer object1 = new Customer();

Quando viene creata un'istanza di una classe, al programmatore viene restituito un riferimento all'oggetto. Nell'esempio precedente object1 è un riferimento a un oggetto basato su Customer. Fa riferimento al nuovo oggetto, ma non contiene i dati dell'oggetto stesso. In realtà è possibile creare un riferimento a un oggetto anche senza creare l'oggetto:

Customer object2;

Non è consigliabile creare riferimenti a oggetti come questo che non fa riferimento a un oggetto, perché il tentativo di accedere a un oggetto tramite tale riferimento genererà un errore in fase di esecuzione. È tuttavia possibile creare un riferimento a un oggetto, creando un nuovo oggetto oppure assegnandolo a un oggetto esistente, come illustrato di seguito:

Customer object3 = new Customer();
Customer object4 = object3;

Con questo codice vengono creati due riferimenti allo stesso oggetto. Pertanto le modifiche effettuate all'oggetto tramite object3 si rifletteranno nei successivi utilizzi di object4, perché agli oggetti basati su classi viene fatto riferimento mediante riferimento, in quanto le classi sono note come tipi riferimento.

Ereditarietà delle classi

L'ereditarietà si ottiene tramite l'utilizzo di una derivazione, ossia una classe viene dichiarata mediante una classe di base da cui eredita dati e comportamenti. Una classe base viene specificata aggiungendo un segno di due punti e il nome della classe base dopo il nome della classe derivata, come illustrato di seguito:

public class Manager : Employee
{
    // Employee fields, properties, methods and events are inherited
    // New Manager fields, properties, methods and events go here...
}

Quando una classe dichiara una classe di base, eredita tutti i membri di quest'ultima, tranne i costruttori.

A differenza del C++, in C# una classe può ereditare direttamente da una sola classe base. Tuttavia, dato che una classe base può ereditare a sua volta da un'altra classe, una classe può ereditare indirettamente da più classi base. Inoltre, una classe può implementare direttamente più di un'interfaccia. Per ulteriori informazioni, vedere Interfacce (Guida per programmatori C#).

Una classe può essere dichiarata astratta. Una classe astratta contiene metodi astratti che dispongono di una definizione della firma, ma non dispongono di implementazione. Non è possibile creare istanze di una classe astratta. È possibile utilizzarla solo tramite classi derivate che implementano i metodi astratti. Al contrario, una classe sealed non consente alle altre classi di derivare da sé stessa. Per ulteriori informazioni, vedere la classe Classi e membri delle classi astratte e sealed (Guida per programmatori C#).

Le definizioni di classe possono essere suddivise tra file di origine differenti. Per ulteriori informazioni, vedere Classi e metodi parziali (Guida per programmatori C#).

Descrizione

Nell'esempio seguente viene definita una classe pubblica, contenente un unico campo, un metodo e un metodo speciale denominato costruttore. Per ulteriori informazioni, vedere Costruttori (Guida per programmatori C#). Viene quindi creata un'istanza di questa classe con la parola chiave new.

Esempio

public class Person
{
    // Field
    public string name;

    // Constructor
    public Person()
    {
        name = "unknown";
    }

    // Method
    public void SetName(string newName)
    {
        name = newName;
    }
}
class TestPerson
{
    static void Main()
    {
        Person person = new Person();
        Console.WriteLine(person.name);

        person.SetName("John Smith");
        Console.WriteLine(person.name);

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Output:
    unknown
    John Smith
*/