Programmazione orientata a oggetti (C# e Visual Basic)

Tutti i linguaggi gestiti in .NET Framework, ad esempio Visual Basic e C#, forniscono il supporto completo perla programmazione orientata a oggetti, inclusi incapsulamento, ereditarietà e polimorfismo.

L'incapsulamento indica che un gruppo di proprietà, metodi e altri membri correlati vengono considerati come una singola unità o un singolo oggetto.

L'ereditarietà indica la capacità di creare nuove classi sulla base di una classe esistente.

Il polimorfismo indica la capacità di utilizzare più classi in modo intercambiabile, anche se in ognuna di esse le stesse proprietà o gli stessi metodi sono implementati in modi diversi.

In questa sezione vengono descritti i concetti seguenti:

• Classi e oggetti

  • Membri della classe

    Proprietà e campi

    Metodi

    Costruttori

    Distruttori

    Eventi

    Classi annidate

  • Modificatori di accesso e livelli di accesso

  • Creazione di istanze di classi

  • Classi e membri statici (condivisi)

  • Tipi anonimi

• Ereditarietà

  • Override di membri

• Interfacce

• Generics

• Delegati

Classi e oggetti

I termini classe e oggetto vengono talvolta utilizzati in modo intercambiabile. Di fatto, però, le classi descrivono il tipo degli oggetti, mentre gli oggetti sono istanze utilizzabili delle classi. L'atto di creare un oggetto viene pertanto chiamato creazione di istanze. Rifacendoci all'analogia precedente, la classe corrisponde al progetto iniziale e l'oggetto all'edificio realizzato in base a tale progetto.

Per definire una classe:

Class SampleClass
End Class

class SampleClass
{
}

Sia Visual Basic che C# forniscono anche una versione ridotta delle classi chiamate strutture utili quando è necessario creare una matrice di grandi dimensioni di oggetti e non si desidera utilizzare a tale scopo una quantità eccessiva di memoria.

Per definire una struttura:

Structure SampleStructure
End Structure

struct SampleStruct
{
}

Per ulteriori informazioni, vedere:

• Visual Basic

  • Istruzione Class (Visual Basic)

  • Istruzione Structure

• C#

  • class (Riferimenti per C#)

  • struct (Riferimenti per C#)

Membri di classe

Ogni classe può disporre di membri della classe diversi che includono proprietà che descrivono i dati della classe, i metodi che definiscono il comportamento della classe e gli eventi che forniscono la comunicazione tra classi e oggetti diversi.

Proprietà e campi

I campi e le proprietà rappresentano le informazioni contenute in un oggetto. I campi sono simili a variabili in quanto possono essere letti o impostati direttamente.

Per definire un campo:

Class SampleClass
    Public SampleField As String
End Class

Class SampleClass
{
    public string sampleField;
}

Le proprietà dispongono di routine Get e Set, che forniscono un maggiore controllo sul modo in cui i valori vengono impostati o restituiti.

Sia C# che Visual Basic consentono di creare un campo privato per archiviare il valore della proprietà o utilizzare le cosiddette proprietà implementate automaticamente che creano automaticamente questo campo e forniscono la logica di base per le routine della proprietà.

Per definire una proprietà implementata automaticamente:

Class SampleClass
    Public Property SampleProperty as String
End Class

class SampleClass
{
    public int SampleProperty { get; set; }
}

Se è necessario eseguire alcune operazioni aggiuntive per la lettura e la scrittura del valore della proprietà, definire un campo per archiviare il valore della proprietà e fornire la logica di base per archiviarlo e recuperarlo:

Class Samplelass
    Private m_Sample As String
    Public Property Sample() As String
        Get
            ' Return the value stored in the field.
            Return m_Sample
        End Get
        Set(ByVal Value As String)
            ' Store the value in the field.
            m_Sample = Value
        End Set
    End Property
End Class

class SampleClass
{
    private int _sample;
    public int Sample
    {
        // Return the value stored in a field.
        get { return _sample; }
        // Store the value in the field.
        set { _sample = value; }
    }
}

La maggior parte delle proprietà dispone di metodi o di routine per impostare e ottenere il valore della proprietà. È possibile, tuttavia, creare proprietà di sola lettura o di sola scrittura per impedirne la modifica o la lettura. In Visual Basic è possibile utilizzare le parole chiave ReadOnly e WriteOnly. In C#, è possibile omettere il metodo della proprietà get o set. Sia in Visual Basic che in C#, tuttavia, le proprietà implementate automaticamente non possono essere di sola lettura o di sola scrittura.

Per ulteriori informazioni, vedere:

• Visual Basic

  • Istruzione Property

  • Istruzione Get

  • Istruzione Set (Visual Basic)

  • ReadOnly (Visual Basic)

  • WriteOnly (Visual Basic)

• C#

  • get (Riferimenti per C#)

  • set (Riferimenti per C#)

Metodi

Un metodo è un'azione che può essere eseguita da un oggetto.

Nota

In Visual Basic, è possibile creare un metodo in due modi: se il metodo non restituisce un valore, viene utilizzata l'istruzione Sub, se invece un metodo restituisce un valore, viene utilizzata l'istruzione Function.

Per definire un metodo di una classe:

Class SampleClass
    Public Function SampleFunc(ByVal SampleParam As String)
        ' Add code here
    End Function
End Class

class SampleClass
{
    public int sampleMethod(string sampleParam)
    {
        // Insert code here
    }
}

Una classe può disporre di diverse implementazioni, o overload, dello stesso metodo che differiscono per il numero di parametri o per i tipi di parametro.

Per essere in rapporto di overload con un metodo:

Overloads Sub Display(ByVal theChar As Char)
    ' Add code that displays Char data.
End Sub
Overloads Sub Display(ByVal theInteger As Integer)
    ' Add code that displays Integer data.
End Sub

public int sampleMethod(string sampleParam) {};
public int sampleMethod(int sampleParam) {}

Nella maggior parte dei casi si dichiara un metodo all'interno di una definizione della classe. Sia Visual Basic che C#, tuttavia, supportano inoltre i metodi di estensione che consentono di aggiungere metodi a una classe esistente al di fuori della definizione effettiva della classe.

Per ulteriori informazioni, vedere:

• Visual Basic

  • Istruzione Function (Visual Basic)

  • Istruzione Sub (Visual Basic)

  • Overloads (Visual Basic)

  • Metodi di estensione (Visual Basic)

• C#

  • Metodi (Guida per programmatori C#)

  • Metodi di estensione (Guida per programmatori C#)

Costruttori

I costruttori sono metodi di classe che vengono eseguiti automaticamente durante la creazione di un oggetto di un tipo specifico. I costruttori in genere inizializzano i membri dati del nuovo oggetto. Un costruttore può essere eseguito solo una volta alla creazione di una classe. Inoltre, il codice nel costruttore viene sempre eseguito prima di qualsiasi altro codice in una classe. Tuttavia, è possibile creare più overload del costruttore esattamente come per qualsiasi altro metodo.

Per definire un costruttore per una classe:

Class SampleClass
    Sub New(ByVal s As String)
        // Add code here.
    End Sub
End Class

public class SampleClass
{
    public SampleClass()
    {
        // Add code here
    }
}

Per ulteriori informazioni, vedere:

• Visual Basic

  • Sub New

  • Object Lifetime: How Objects Are Created and Destroyed

• C#

  • Costruttori (Guida per programmatori C#)

Distruttori

I distruttori sono utilizzati per distruggere istanze di classi. In .NET Framework, il Garbage Collector gestisce l'allocazione e il rilascio di memoria per gli oggetti gestiti di un'applicazione. Potrebbero, tuttavia, essere necessari distruttori per pulire eventuali risorse non gestite create dall'applicazione. Può esistere un solo distruttore per classe.

Per ulteriori informazioni sui distruttori e sull'operazione di Garbage Collection in .NET Framework, vedere Garbage Collection.

Eventi

Tramite gli eventi una classe o un oggetto sono in grado di segnalare ad altre classi o oggetti una situazione di interesse. La classe che invia (o genera) l'evento è chiamata autore e le classi che ricevono (o gestiscono) l'evento sono chiamate sottoscrittori. Per ulteriori informazioni sugli eventi e sulla corrispondente modalità di generazione e gestione, vedere Gestione e generazione di eventi.

• Visual Basic

  • Per dichiarare gli eventi, utilizzare Istruzione Event.

  • Per generare gli eventi, utilizzare Istruzione RaiseEvent.

  • Per specificare i gestori di eventi tramite una modalità dichiarativa, utilizzare l'istruzione WithEvents (Visual Basic) e la clausola Clausola Handles (Visual Basic).

  • Per aggiungere, rimuovere e modificare dinamicamente il gestore dell'evento associato a un evento, utilizzare l'Istruzione AddHandler e l'Istruzione RemoveHandler insieme all'AddressOf Operator.

• C#

  • Per dichiarare un evento in una classe, utilizzare la parola chiave event (Riferimenti per C#).

  • Per generare un evento, richiamare il delegato dell'evento.

  • Per sottoscrivere un evento, utilizzare l'operatore +=. Per annullare la sottoscrizione a un evento utilizzare l'operatore -=:

Classi annidate

Una classe definita all'interno di un'altra classe è denominata annidata. Per impostazione predefinita, la classe annidata è privata.

Class Container
    Class Nested
    ' Add code here.
    End Class
End Class

class Container
{
    class Nested
    {
        // Add code here.
    }
}

Per creare un'istanza della classe annidata, utilizzare il nome della classe dei contenitori seguita dal punto, quindi dal nome della classe annidata:

Dim nestedInstance As Container.Nested = New Container.Nested()

Container.Nested nestedInstance = new Container.Nested()

Modificatori di accesso e livelli di accesso

Tutte le classi e i membri della classe possono specificare quale livello di accesso forniscono alle altre classi utilizzando i modificatori di accesso.

Sono disponibili i seguenti modificatori di accesso:

Modificatore di Visual Basic	Modificatore di C#	Definizione
Public (Visual Basic)	public	Il tipo o il membro è accessibile da altro codice nello stesso assembly o in un altro assembly che vi fa riferimento.
Private (Visual Basic)	private	Il tipo o il membro è accessibile solo dal codice nella stessa classe.
Protected (Visual Basic)	protected	Il tipo o il membro è accessibile solo dal codice nella stessa classe o in una classe derivata.
Friend (Visual Basic)	internal	Il tipo o il membro è accessibile dal codice nello stesso assembly ma non da un altro assembly.
Protected Friend	protected internal	Il tipo o il membro è accessibile dal codice nello stesso assembly o da una classe derivata in un altro assembly.

Per ulteriori informazioni, vedere Access Levels in Visual Basic e Modificatori di accesso (Guida per programmatori C#).

Creazione di istanze di classi

Per creare un oggetto, è necessario creare un'istanza di una classe.

Dim sampleObject as New SampleClass()

SampleClass sampleObject = new SampleClass();

Dopo avere creato un'istanza di una classe, è possibile assegnare i valori alle proprietà e ai campi dell'istanza e richiamare i metodi della classe.

' Set a property value.
sampleObject.SampleProperty = "Sample String"
' Call a method.
sampleObject.SampleMethod()

// Set a property value.
sampleObject.sampleProperty = "Sample String";
// Call a method.
sampleObject.sampleMethod();

Per assegnare i valori alle proprietà durante il processo di creazione dell'istanza della classe, utilizzare gli inizializzatori di oggetto:

Dim sampleObject = New SampleClass With 
    {.FirstProperty = "A", .SecondProperty = "B"}

// Set a property value.
SampleClass sampleObject = new SampleClass 
    { FirstProperty = "A", SecondProperty = "B" };

Per ulteriori informazioni, vedere:

• Visual Basic

  • Operatore New (Visual Basic)

  • Object Initializers: Named and Anonymous Types

• C#

  • Operatore new (Riferimenti per C#)

  • Inizializzatori di oggetto e di insieme (Guida per programmatori C#)

Classi e membri statici (condivisi)

Un membro statico (condiviso in Visual Basic) della classe è una proprietà, una routine o un campo condiviso da tutte le istanze di una classe.

Per definire un membro statico (condiviso):

Class SampleClass
    Public Shared SampleString As String = "Sample String"
End Class

static class SampleClass
{
    public static string SampleString = "Sample String";
}

Per accedere al membro statico (condiviso), utilizzare il nome della classe senza creare un oggetto di questa classe:

MsgBox(SampleClass.SampleString)

Console.WriteLine(SampleClass.SampleString);

Le classi statiche (condivise) in C# e i moduli in Visual Basic dispongono solo di membri statici (condivisi) e non è possibile crearne un'istanza. I membri statici (condivisi) non possono accedere inoltre a proprietà, campi o metodi non statici (non condivisi)

Per ulteriori informazioni, vedere:

• Visual Basic

  • Shared (Visual Basic)

  • Istruzione Module

• C#

  • static (Riferimenti per C#)

Tipi anonimi

I tipi anonimi consentono di creare oggetti senza scrivere una definizione della classe per il tipo di dati. La classe viene generata direttamente dal compilatore. La classe non ha un nome utilizzabile e contiene le proprietà specificate nella dichiarazione dell'oggetto.

Per creare un'istanza di un tipo anonimo:

' sampleObject is an instance of a simple anonymous type.
Dim sampleObject = 
    New With {Key .FirstProperty = "A", .SecondProperty = "B"}

// sampleObject is an instance of a simple anonymous type.
var sampleObject = 
    new { FirstProperty = "A", SecondProperty = "B" };

Per ulteriori informazioni, vedere:

• Visual Basic: Anonymous Types

• C#: Tipi anonimi (Guida per programmatori C#)

Ereditarietà

L'ereditarietà permette di creare una nuova classe che riutilizza, estende e modifica il comportamento definito in un'altra classe. La classe i cui membri vengono ereditati è denominata classe base, mentre la classe che eredita tali membri è denominata classe derivata. Tuttavia, tutte le classi sia in C# che in Visual Basic ereditano in modo implicito dalla classe Object che supporta la gerarchia di classi .NET e fornisce servizi di basso livello a tutte le classi.

Nota

I linguaggi gestiti in .NET Framework non supportano l'ereditarietà multipla, ad esempio è possibile specificare una sola classe di base per una classe derivata.

Per ereditare da una classe base:

Class DerivedClass
    Inherits BaseClass
End Class

class DerivedClass:BaseClass{}

Per impostazione predefinita, tutte le classi possono essere ereditate. Tuttavia, è possibile specificare se una classe non deve essere utilizzata come classe base oppure creare una classe utilizzabile solo come classe base.

Per specificare che una classe non può essere utilizzata come classe base:

NotInheritable Class SampleClass
End Class

public sealed class A { }

Per specificare che una classe può essere utilizzata solo come classe base e che non è possibile crearne un'istanza:

MustInherit Class BaseClass
End Class

public abstract class B { }

Per ulteriori informazioni, vedere:

• Visual Basic

  • Istruzione Inherits

  • NotInheritable (Visual Basic)

  • MustInherit (Visual Basic)

• C#

  • sealed (Riferimenti per C#)

  • abstract (Riferimenti per C#)

Override di membri

Per impostazione predefinita, in una classe derivata vengono ereditati tutti i membri della classe base relativa. Se si desidera modificare il comportamento del membro ereditato, è necessario eseguirne l'override. È possibile definire una nuova implementazione del metodo, della proprietà o dell'evento nella classe derivata.

I seguenti modificatori consentono di controllare le modalità di override di proprietà e metodi:

Modificatore di Visual Basic	Modificatore di C#	Definizione
Overridable (Visual Basic)	virtual (Riferimenti per C#)	Consente a un membro della classe di essere sottoposto a override in una classe derivata.
Overrides (Visual Basic)	override (C# Reference)	Esegue l'override di un membro virtuale (sottoponibile a override) definito nella classe base.
NotOverridable (Visual Basic)	Non supportato	Consente di impedire l'override di un membro in una classe che eredita.
MustOverride (Visual Basic)	abstract (Riferimenti per C#)	Richiede che un membro della classe venga sottoposto a override nella classe derivata.
Shadows (Visual Basic)	Modificatore new (Riferimenti per C#)	Nasconde un membro ereditato da una classe base.

Interfacce

Le interfacce, come le classi, consentono di definire un insieme di proprietà, metodi ed eventi. A differenza delle classi, però, le interfacce non forniscono l'implementazione. Esse sono infatti implementate dalle classi e definite come entità distinte da queste. Un'interfaccia rappresenta un contratto, in quanto è necessario che una classe che implementa un'interfaccia implementi ogni aspetto esattamente come è stato definito.

Per definire un'interfaccia:

Public Interface ISampleInterface
    Sub DoSomething()
End Interface

interface ISampleInterface
{
    void doSomething();
}

Per implementare un'interfaccia in una classe:

Class SampleClass
    Implements ISampleInterface
    Sub doSomething
        ' Method implementation.
    End Sub
End Class

class SampleClass : ISampleInterface
{
    void ISampleInterface.SampleMethod()
    {
        // Method implementation.
    }
}

Per ulteriori informazioni, vedere:

• Visual Basic

  • Interfacce (Visual Basic)

  • Istruzione Interface (Visual Basic)

  • Istruzione Implements

• C#

  • Interfacce (Guida per programmatori C#)

  • interface (Riferimenti per C#)

Generics

Classi, strutture, interfacce e metodi in .NET Framework sono in grado di digitare parametri che definiscono tipi di oggetti che possono archiviare o utilizzare. L'esempio più comune di generics è un insieme, dove è possibile specificare il tipo di oggetti da archiviare in un insieme.

Per definire una classe generica:

Class SampleGeneric(Of T)
    Public Field As T
End Class

Public class SampleGeneric<T> 
{
    public T Field;
}

Per creare un'istanza di una classe generica:

Dim sampleObject As New SampleGeneric(Of String)
sampleObject.Field = "Sample string"

SampleGeneric<string> sampleObject = new SampleGeneric<string>();
sampleObject.Field = "Sample string";

Per ulteriori informazioni, vedere:

• Generics in .NET Framework

• Generic Types in Visual Basic

• Generics (Guida per programmatori C#)

Delegati

Un delegato è un tipo che definisce una firma di metodo e può fornire un riferimento a qualsiasi metodo con una firma compatibile. Tramite il delegato è possibile invocare (o chiamare) il metodo. I delegati vengono utilizzati per passare metodi come argomenti ad altri metodi.

Nota

I gestori di evento non sono altro che metodi richiamati tramite delegati. Per ulteriori informazioni sull'utilizzo dei delegati nella gestione degli eventi, vedere Eventi e delegati.

Per creare un delegato:

Delegate Sub SampleDelegate(ByVal str As String)

public delegate void SampleDelegate(string str);

Per creare un riferimento a un metodo che corrisponde alla firma specificata dal delegato:

Class SampleClass
    ' Method that matches the SampleDelegate signature.
    Sub SampleSub(ByVal str As String)
        ' Add code here.
    End Sub
    ' Method that instantiates the delegate.
    Sub SampleDelegateSub()
        Dim sd As SampleDelegate = AddressOf SampleSub
        sd("Sample string")
    End Sub
End Class

class SampleClass
{
    // Method that matches the SampleDelegate signature.
    public static void sampleMethod(string message)
    {
        // Add code here.
    }
    // Method that instantiates the delegate.
    void SampleDelegate()
    {
        SampleDelegate sd = sampleMethod;
        sd("Sample string");
    }
}

Per ulteriori informazioni, vedere:

• Visual Basic

  • Delegati (Visual Basic)

  • Istruzione Delegate

  • AddressOf Operator

• C#

  • Delegati (Guida per programmatori C#)

  • delegate (C# Reference)

Vedere anche

Concetti

C# Programming Guide

Altre risorse

Visual Basic Programming Guide