Questa pagina è stata utile?
I suggerimenti relativi al contenuto di questa pagina sono importanti. Comunicaceli.
Altri suggerimenti?
1500 caratteri rimanenti
Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto manualmente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale.
Traduzione
Originale

Classi e struct (Guida per programmatori C#)

Classi e strutture sono due dei costrutti di base del Common Type System in .NET Framework. Ognuno di essi è essenzialmente una struttura di dati che incapsula un insieme di dati e comportamenti strettamente correlati a costituire un'unità logica. I dati e i comportamenti sono i membri della classe o della struttura e includono i metodi, le proprietà, gli eventi, ecc., come elencato in seguito in questo argomento.

Una classe o una dichiarazione della struttura è come un progetto iniziale utilizzato per creare istanze o oggetti in fase di esecuzione . Se si definisce una classe o una struttura chiamata Person, Person è il nome del tipo. Se si dichiara e inizializza una variabile p di tipo Person, si dice che p sia un oggetto o un'istanza di Person. È possibile creare istanze Multiple dello stesso tipo Person e ogni istanza può disporre di valori diversi nelle proprietà e nei campi.

Una classe è un tipo di riferimento. Quando viene creato un oggetto della classe, la variabile alla quale è assegnato l'oggetto contiene solo un riferimento a quella memoria. Quando il riferimento a un oggetto è assegnato a una nuova variabile, la nuova variabile si riferisce all'oggetto originale. Le modifiche apportate tramite una variabile vengono riflesse nell'altra variabile perché entrambe si riferiscono agli stessi dati.

Una struttura è un tipo di valore. Quando viene creata una struttura, la variabile alla quale è assegnata, contiene i dati effettivi della struttura. Quando la struttura è assegnata a una nuova variabile, viene copiata. La nuova variabile e la variabile originale contengono pertanto due copie separate degli stessi dati. Eventuali modifiche apportate a una copia non influiscono sull'altra copia.

In generale, le classi sono utilizzate per modellare un comportamento più complesso o dati che devono essere modificati dopo la creazione di un oggetto di classe. Le strutture sono più adatte per piccole strutture di dati contenenti principalmente dati che non devono essere modificati dopo la creazione della struttura.

Per ulteriori informazioni, vedere Classi (Guida per programmatori C#), Oggetti (Guida per programmatori C#) e Struct (Guida per programmatori C#).

Nell'esempio seguente viene definita la classe MyCustomClass con tre membri in corrispondenza del livello superiore dello spazio dei nomi ProgrammingGuide. Viene creata un'istanza (oggetto) di MyCustomClass nel metodo Main della classe Program. I metodi e le proprietà dell'oggetto sono accessibili tramite notazione del punto.


    namespace ProgrammingGuide
    {
        // Class definition.
        public class MyCustomClass
        {
            // Class members:
            // Property.
            public int Number { get; set; }

            // Method.
            public int Multiply(int num)
            {
                return num * Number;
            }

            // Instance Constructor.
            public MyCustomClass()
            {
                Number = 0;
            }
        }
        // Another class definition. This one contains
        // the Main method, the entry point for the program.
        class Program
        {
            static void Main(string[] args)
            {
                // Create an object of type MyCustomClass.
                MyCustomClass myClass = new MyCustomClass();

                // Set the value of a public property.
                myClass.Number = 27;

                // Call a public method.
                int result = myClass.Multiply(4);
            }
        }
    }



L'incapsulamento talvolta è definito come il primo pilastro o il principio della programmazione orientata a oggetti. In base al principio di incapsulamento, una classe o una struttura possono specificare il modo in cui ognuno dei membri è accessibile al codice esterno alla classe o alla struttura. Metodi e variabili che non devono essere utilizzati dall'esterno della classe o dell'assembly possono essere nascosti per limitare il rischio di errori di codifica o esiti dannosi.

Per ulteriori informazioni sulle classi, vedere Classi (Guida per programmatori C#) e Oggetti (Guida per programmatori C#). Per ulteriori informazioni sulla progettazione di classi, vedere Linee guida di progettazione dei tipi.

Membri

Tutti i metodi, campi, costanti, proprietà ed eventi devono essere dichiarati all'interno di un tipo: sono chiamati i membri della classe o della struttura. In C#, non esistono variabili o metodi globali come in altri linguaggi. Anche il punto di ingresso del programma, il metodo Main deve essere dichiarato all'interno di una classe o di una struttura. Nell'elenco seguente sono inclusi tutti i vari tipi di membri che possono essere dichiarati in una classe o in una struttura.

Accessibilità

Alcuni metodi e proprietà devono essere chiamati o resi accessibili a codice esterno alla classe o struttura, noto come codice client. Altri metodi e proprietà possono essere riservati esclusivamente ad un utilizzo all'interno della stessa classe o struttura. Ciò è importante per limitare l'accessibilità del codice in modo che solo il codice client desiderato possa raggiungerlo. È possibile specificare il modo in cui è possibile accedere ai tipi e ai relativi membri dal codice client, utilizzando i modificatori di accesso public, protected, internal, protected internal e private. L'accessibilità predefinita è private. Per ulteriori informazioni, vedere Modificatori di accesso (Guida per programmatori C#).

Ereditarietà

Le classi (ma non le strutture) supportano il concetto di ereditarietà. Una classe che deriva da un'altra classe (la classe di base) contiene automaticamente tutti i membri pubblici, protetti e interni della classe di base, ad eccezione di costruttori e distruttori. Per ulteriori informazioni, vedere Ereditarietà (Guida per programmatori C#) e Polimorfismo (Guida per programmatori C#).

Le classi possono essere dichiarate come astratte, ossia con uno o più metodi senza implementazione. Anche se non è possibile crearne direttamente un'istanza, le classi astratte possono fungere da classi di base per altre classi che forniscono l'implementazione mancante. Le classi possono essere dichiarate anche come sealed per impedire che altre classi ereditino da esse. Per ulteriori informazioni, vedere Classi e membri delle classi astratte e sealed (Guida per programmatori C#).

Interfacce

Le classi e le strutture possono ereditare più interfacce. Ereditare da un'interfaccia significa che il tipo implementa tutti i metodi definiti nell'interfaccia. Per ulteriori informazioni, vedere Interfacce (Guida per programmatori C#).

Tipi generici

Le classi e le strutture possono essere definite con uno o più parametri di tipo. Il codice client fornisce il tipo quando ne crea un'istanza. Ad esempio, la classe List<T> nello spazio dei nomi System.Collections.Generic è definita con un parametro di tipo. Il codice client crea un'istanza di List<string> o List<int> per specificare il tipo che sarà contenuto nell'elenco. Per ulteriori informazioni, vedere Generics (Guida per programmatori C#).

Tipi statici

Le classi (ma non le strutture) possono essere dichiarate come statiche. Una classe statica può contenere solo membri statici e non è possibile crearne un'istanza con la parola chiave new. Una copia della classe viene caricata in memoria durante il caricamento del programma e i relativi membri sono accessibili tramite il nome della classe. Sia le classi che le strutture possono contenere membri statici. Per ulteriori informazioni, vedere Classi statiche e membri di classi statiche (Guida per programmatori C#).

Tipi annidati

Una classe o una struttura possono essere annidate all'interno di un'altra classe o struttura. Per ulteriori informazioni, vedere Tipi annidati.

Tipi parziali

È possibile definire una parte di una classe, struttura o metodo in un file di codice e un'altra parte in un file di codice distinto. Per ulteriori informazioni, vedere Classi e metodi parziali.

Inizializzatori di oggetto

È possibile creare un'istanza e inizializzare oggetti di classi o strutture e insiemi di oggetti, senza chiamare in modo esplicito il relativo costruttore. Per ulteriori informazioni, vedere Inizializzatori di oggetto e di insieme (Guida per programmatori C#).

Tipi anonimi

Nelle situazioni in cui non conviene o non è necessario creare una classe denominata, ad esempio quando si popola un elenco con strutture di dati che non devono necessariamente essere persistenti o passate a un altro metodo, è possibile utilizzare i tipi anonimi. Per ulteriori informazioni, vedere Tipi anonimi (Guida per programmatori C#).

Metodi di estensione

È possibile "estendere" una classe senza creare una classe derivata creando un tipo distinto i cui metodi possono essere chiamati come se appartenessero al tipo originale. Per ulteriori informazioni, vedere Metodi di estensione (Guida per programmatori C#).

Variabili locali tipizzate in modo implicito

All'interno di un metodo di classe o struttura è possibile utilizzare la tipizzazione implicita per indicare al compilatore di determinare il tipo corretto in fase di compilazione. Per ulteriori informazioni, vedere Variabili locali tipizzate in modo implicito (Guida per programmatori C#).

Per ulteriori informazioni, vedere la Specifiche del linguaggio C#. La specifica del linguaggio è la fonte ufficiale per la sintassi e l'utilizzo di C#.

Aggiunte alla community

AGGIUNGI
Mostra:
© 2015 Microsoft