Dopo anni e anni di programmazione, tra C, C++, Visual Basic, Php, Java, C# ed altro, la mia attenzione si è focalizzata su quest'ultimo linguaggio. Da diverso tempo infatti utilizzo questo linguaggio per la totalità dei miei progetti, salvo diverse disposizioni dall'alto. Studiando anche codice altrui sono spesso comparse paroline che suscitavano curiosità, che nel tempo ho studiato, ho compreso ed utilizzato. Negli ultimi giorni ho fatto un pò di confusione, così ho deciso di scrivere questo post, anche per creare un documento utile a me in qualunque momento.
internal
La parola chiave internal è un modificatore d'accesso per i tipi ed i loro membri. I membri definiti con questa parola chiave sono accessibili solo da file che si trovano nello stesso assembly. Non si può fare riferimento a un membro con accesso internal dall'esterno dell'assembly in cui è stato definito.
private
La parola chiave private è un modificatore di accesso di un membro. I membri private sono accessibili solo dall'interno del corpo della classe o della struttura in cui sono dichiarati. I tipi annidati nello stesso corpo possono anch'essi accedere ai membri privati.
protected
Un membro protected è accessibile dall'interno della classe in cui è dichiarato e dall'interno di qualsiasi classi derivata da quella in cui è stato dichiarato. Un membro protected di una classe base è accessibile in una classe derivata solo se l'accesso avviene attraverso il tipo di classe derivato. Non è possibile fare riferimento a un membro protected dall'interno di una classe che non sia derivata dalla classe del membro protetto.
public
Non c'è alcuna restrizione per l'accesso a membri pubblici.
abstract
Il modificatore abstract può essere utilizzato con classi, metodi e proprietà. Va utilizzato in una dichiarazione di classe per indicare che una classe deve funzionare esclusivamente da base per un'altra classe. Le classi astratte hanno le seguenti caratteristiche:
- non possono essere istanziate
- possono contenere metodi astratti
- non è possibile modificarle con il modificatore sealed
- una classe astratta derivata da una astratta deve includere le implementazioni reali di tutti i metodi astratti
Il modificatore abstract in una dichiarazione di metodo o di proprietà indica che il metodo o la proprietà non contengono una implementazione. I metodi astratti hanno le seguenti caratteristiche:
- sono implicitamente metodi virtuali
- le loro dichiarazioni sono consentite solo nelle classi astratte
- poichè la loro dichiarazione non fornisce una implementazione effettiva, non hanno un corpo; la dichiarazione del metodo termine semplicemente con un punto e virgola e non ci sono parentesi graffe dopo la firma
- l'implementazione è fornita da un metodo prevalente, membro di una classe non astratta
Le proprietà abstract funzionano come i metodi abstrac, a parte alcune differenze nella sinstassi della dichiarazione e dell'invocazione.
Una classe abstract che implementa una interfaccia deve fornire l'implementazione di tutti i membri dell'interfaccia oppure può mappare i metodi dell'interfaccia stessa su metodi astratti.
const
La parola chiave const viene utilizzata per modificare la dichiarazione di un campo o di una variabile locale. Specifica che il valore del campo o della variabile locale non possono essere modificati.
Un'espressione costante restituisce un valore del tipo di destinazione o di un tipo che possa essere implicitamente convertito in quello di destinazione.
Un'espressione costante è una espressione che può essere completamente elaborata durante la compilazione, quindi gli unici valori possibile per le costati di tipo di riferimento sono string e null.
Il modificatore static non è consentito in una dichiarazione di costante. Una costante può far parte di un'altra espressione costante.
event
La parola chiave event consente di specificare un delegato che verrà chiamato quando si verifica un evento nel codice. Il delegato può avere un o più metodi che vengono chiamati quando il codice indica che l'evento si è verificato.
extern
Il modificatore extern va utilizzato in una dichiarazione di metodo per indicare che il metodo stesso è implementato esternamente. L'uso più comune di questo modificatore è con l'attributo DllImport. Poichè la dichiarazione esterna di un metodo non fornisce una implementazione reale, non esiste neanche il corpo del metodo; la dichiarazione termina semplicemente con un punto e virgola ed è priva di parentesi graffe.
override
Il modificatore override serve a modificare un metodo o una proprietà. Un metodo di questo tipo fornisce una nuova implementazione di un membro ereditato da una classe base. Il metodo ignorato da una dichiarazione di questo tipo iene detto metodo base. Il metodo base ignorato deve avere la medesima firma del metodo che lo ignora.
Non è possibile ignorare un metodo non virtuale o statico; il metodo base deve essere virtuale, astratto o di tipo override.
Una dichiarazione di override non può modificare l'accessibilità del metodo virtuale: entrambi i metodi in gioco devono avere lo stesso modificatore di accesso. Non è possibile utilizzare i seguenti modificatori per modificare un metodo override:
-
new
-
static
-
virtual
-
abstract
Una dichiarazione di proprietà che ne ignori un'altra deve specificare il medesimo modificatore d'accesso, tipo e nome della proprietà ereditata e la proprietà ignorata deve essere virtuale, astratta o override.
readonly
La parola chiave readonly è un modificatore che si può utilizzare con i campi. Quando una dichiarazione di campo è marcata con il modificatore readonly le assegnazioni ai campi introdotte dalla dichiarazione possono essere eseguite solo come parte della dichiarazione o in un costruttore della medesima classe.
sealed
La parola chiave sealed è un modificatore che si pul utilizzare in una dichiarazione di classe per evitare di ereditare accidentalmente la classe. Non è possibile utilizzare il modificatore abstract con una classe sealed. Le struct sono implicitamente sealed, quindi non possono essere ereditate.
static
Il modificatore static serve a dichiarare un membro statico che appartiene al tipo stesso e non ad un oggetto specifico. Il modificatore static può essere utilizzato con campi, metodi, proprietà, operatori e costruttori, ma non con indicizzatori, distruttori o tipi.
Nota: anche se una istanza di una classe contiene una copia di tutti i campi dell'istanza della classe, c'è una sola copia per ciascun campo statico.
unsafe
La parola chiave unsafe indica un contesto unsafe, richiesto per le operazione che coinvolgono i puntatori. Questa parola chiave viene utilizzata come modificate nella dichiarazione di membri invocabili come metodi, proprietà, costruttori ed estensori, ma non per i costruttori static.
static unsafe void Metodo(byte[] first, byte[] second, int count)
{
// Contesto unsafe, si possono utilizzare i puntatori
}
L'ambito di un contesto unsafe va dall'elenco dei parametri fino al termine della funzione, quindi è possibile utilizzare i puntatori anche nell'elenco dei parametri.
static unsafe void Metodo(byte* first, byte* second, int count)
{...}
Per compilare il codice non gestito è necessario specificare l'opzione /unsafe del compilatore.
virtual
La parola chiave virtual serve a modificare una dichiarazione di un metodo o di una proprietà (in questi casi il metodo o la proprietà diventano membri virtuali). L'implementazione di un metodo virtual può essere cambiata da un metodo in una classe derivata. Di default i metodi non sono virtuali. Non è possibile prevalere su un metodo non virtuale nè utilizzare il modificatore virtual con i modificatori static, abstract e override.
Le proprietà virtuali si comportano come i metodi abstract, con alcune differenze nella sintassi della dichiarazione e della chiamata. Non è possibile utilizzare il modificatore virtual con una proprietà static. Una proprietà virtuale ereditata può essere ignorata in una classe derivata includendo una dichiarazione di proprietà che utilizza il modificatore override.
volatile
La parola chiave volatile indica che un campo può essere modificato nel programma dal sistema operativo, dall'hardware o da un thread concorrente.
Questo modificatore viene in genere utilizzato per i campi a cui si accede da parte di più thread senza utilizzare l'istruzione lock per serializzare l'accesso. L'uso di questo modificatore assicura che un thread legga il valore più aggiornato scritto da un altro thread.
Solo i seguenti tipi possono essere contrassegnati come volatili:
-
tipi di riferimento
-
tipi puntatore (in contesto unsafe)
-
sbyte, byte, short, ushort, int,uint, char, float, bool
-
tipi enumeratore con una base byte, sbyte, short, ushort, int o uint