Introduzione alle classi

Tipi riferimento

Un tipo definito come è un classclass. In fase di esecuzione, quando si dichiara una variabile di un tipo riferimento, nullnew la variabile contiene il valore fino a quando non si crea in modo esplicito un'istanza della classe usando l'operatore o si assegna un oggetto di un tipo compatibile che potrebbe essere stato creato altrove, come illustrato nell'esempio seguente:

//Declaring an object of type MyClass.
MyClass mc = new MyClass();

//Declaring another object of the same type, assigning it the value of the first object.
MyClass mc2 = mc;

Quando viene creato l'oggetto, una quantità di memoria sufficiente viene allocata nell'heap gestito per l'oggetto specifico e la variabile mantiene solo un riferimento al percorso dell'oggetto. I tipi nell'heap gestito richiedono un overhead quando vengono allocati e recuperati dalla funzionalità di gestione automatica della memoria di CLR, nota come Garbage Collection. La Garbage Collection, tuttavia, è anche altamente ottimizzata e, nella maggior parte degli scenari, non genera un problema di prestazioni. Per altre informazioni sulla Garbage Collection, vedere Gestione automatica della memoria e Garbage Collection.

Dichiarazione di classi

Le classi vengono dichiarate usando la parola class chiave seguita da un identificatore univoco, come illustrato nell'esempio seguente:

//[access modifier] - [class] - [identifier]
public class Customer
{
   // Fields, properties, methods and events go here...
}

La parola chiave class è preceduta dal livello di accesso. Poiché public viene usato in questo caso, chiunque può creare istanze di questa classe. Il nome della classe segue la parola chiave class. Il nome della classe deve essere un nome di identificatore C# valido. Il resto della definizione è il corpo della classe, in cui vengono definiti il comportamento e i dati. I campi, le proprietà, i metodi e gli eventi in una classe vengono collettivamente definiti membri della classe.

Creazione di oggetti

Anche se vengono talvolta usati in modo intercambiabile, una classe e un oggetto sono elementi diversi. Una classe definisce un tipo di oggetto, ma non è un oggetto. Un oggetto è un'entità concreta ed è basato su una classe. Talvolta si fa riferimento all'oggetto come istanza di una classe.

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

Customer object1 = new Customer();

Quando viene creata un'istanza di una classe, viene passato al programmatore un riferimento all'oggetto. Nell'esempio precedente, object1 è un riferimento a un oggetto basato su Customer. Questo riferimento indica il nuovo oggetto, ma non contiene i dati dell'oggetto. Infatti, è possibile creare un riferimento all'oggetto senza creare un oggetto:

 Customer object2;

Non è consigliabile creare riferimenti a oggetti come quello precedente che non fanno riferimento a un oggetto perché il tentativo di accedere a un oggetto tramite tale riferimento avrà esito negativo in fase di esecuzione. Tuttavia, tale riferimento può essere fatto per fare riferimento a un oggetto, creando un nuovo oggetto o assegnando un oggetto esistente, ad esempio:

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

Questo codice crea due riferimenti a oggetti che fanno entrambi riferimento allo stesso oggetto. Tutte le modifiche effettuate all'oggetto tramite object3 si riflettono tuttavia nei successivi usi di object4. Poiché gli oggetti che si basano su classi vengono indicati tramite riferimenti, le classi sono note come tipi di riferimento.

Ereditarietà delle classi

Le classi supportano completamente l'ereditarietà, una caratteristica fondamentale nella programmazione orientata a oggetti. Quando si crea una classe, sealedè possibile ereditare da qualsiasi altra classe non definita come e altre classi possono ereditare dalla classe ed eseguire l'override dei metodi virtuali della classe. Inoltre, è possibile implementare una o più interfacce.

L'ereditarietà si ottiene usando una derivazione, vale a dire che una classe viene dichiarata usando una classe di base da cui eredita dati e comportamento. Una classe di base viene specificata tramite l'aggiunta di due punti e il nome della classe di base dopo il nome della classe derivata, nel modo seguente:

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 della classe di base, a eccezione dei costruttori. Per altre informazioni, vedere Ereditarietà.

Una classe in C# può ereditare direttamente solo da una classe di base. Tuttavia, poiché una classe di base può ereditare da un'altra classe, una classe può ereditare indirettamente più classi di base. Inoltre, una classe può implementare direttamente una o più interfacce. Per ulteriori informazioni, vedi Interfacce.

Una classe può essere dichiarata abstract. Una classe astratta contiene metodi astratti che hanno una definizione di firma, ma senza implementazione. Non è possibile creare un'istanza di classi astratte. Le classi astratte possono essere usate solo tramite classi derivate che implementano i metodi astratti. Al contrario, una classe sealed non consente ad altre classi di derivare da tale classe. Per altre informazioni, vedere Classi e membri di classi abstract e sealed.

Le definizioni di classe possono essere suddivise tra file di origine diversa. Per altre informazioni, vedere Classi e metodi parziali.

Esempio

L'esempio seguente definisce una classe pubblica che contiene una proprietà implementata automaticamente, un metodo e un metodo speciale denominato costruttore. Per altre informazioni, vedere gli articoli proprietà, metodie costruttori. Le istanze della classe vengono quindi create con la parola chiave new.

using System;

public class Person
{
    // Constructor that takes no arguments:
    public Person()
    {
        Name = "unknown";
    }

    // Constructor that takes one argument:
    public Person(string name)
    {
        Name = name;
    }

    // Auto-implemented readonly property:
    public string Name { get; }

    // Method that overrides the base class (System.Object) implementation.
    public override string ToString()
    {
        return Name;
    }
}
class TestPerson
{
    static void Main()
    {
        // Call the constructor that has no parameters.
        var person1 = new Person();
        Console.WriteLine(person1.Name);

        // Call the constructor that has one parameter.
        var person2 = new Person("Sarah Jones");
        Console.WriteLine(person2.Name);
        // Get the string representation of the person2 instance.
        Console.WriteLine(person2);
    }
}
// Output:
// unknown
// Sarah Jones
// Sarah Jones

Specifiche del linguaggio C#

Per altre informazioni, vedere specifica del linguaggio C#. La specifica del linguaggio costituisce il riferimento ufficiale principale per la sintassi e l'uso di C#.