C# - Interfacce e Classi Astratte

Interfacce
   •   Una interfaccia è un insieme di 'firme' di proprietà, metodi, delegati e eventi. Per firme si intende che le proprietà, i metodi e gli eventi sono solo definiti come nome, parametri di input e di output, ma non ne è specificato il funzionamento.
   •   Per essere utilizzabile, una interfaccia deve essere 'implementata' da una classe, che ne specifica quindi il funzionamento nel dettaglio.
   •   Una interfaccia non può essere istanziata e non contiene codice che definisce i suoi membri, semplicemente definisce solo i membri. È la classe che implementa l'interfaccia che definisce i membri.
   •   Una classe può implementare più interfacce, così come più classi possono implementare la stessa interfaccia.
   •   Tramite una interfaccia è quindi possibile sostituire un oggetto con un altro, o con un aggiornamento dello stesso oggetto, purché implementino la stessa interfaccia.
   •   Per convenzione le interfacce hanno nomi che iniziano con 'I'.
   •   Una volta pubblicata una interfaccia è buona regola non modificarla per non causare problemi agli oggetti che la implementano. Se occorre modificarla, se ne crea un'altra con un nuovo nome (tipicamente lo stesso nome seguito da 'X2').
   •   Non è possibile istanziare una interfaccia ma si può creare una variabile che punta a ad una istanza di una classe derivata dall'interfaccia. (Esempio: interfaccia I1, classe derivata C1, istanza dell'oggetto c1 dalla classe C1, variabile i1 che punta allo stesso indirizzo di c1).

Interfaccia IDisposable
   •   Una interfaccia particolarmente utile è IDisposable. Essa espone la firma del metodo Dispose() che viene richiamato quando un oggetto non è più utile e si possono liberare risorse di memoria (prima che questo venga fatto dal Garbage Collector).
   •   La parola chiave using, permette di definire un oggetto che utilizza risorse di memoria critiche, in un blocco racchiuso tra '{' e '}'; il metodo Dispose() è richiamato automaticamente al termine del blocco di codice.

Esempio di Interfaccia
   •   In questo esempio si ha l'interfaccia 'ILog' con il metodo 'Print()' del quale è presente solo la firma.
   •   La classe 'MyLog' è ereditata dall'interfaccia e presenta l'implementazione del metodo 'Print()'.
   •   Infine il programma principale che istanzia un oggetto della classe 'MyLog'.

   class Program
   {
       static void Main(string[] args)
       {
           MyLog log = new MyLog();
           log.Print("Log message.");
           Console.ReadKey();
       }
   }

   interface ILog
   {
       void Print(string message);
   }

   class MyLog : ILog
   {
       public void Print(string message)
       {
           Console.WriteLine(message);
       }
   }

   •   Tentativo di istanziare l'interfaccia e variabile di tipo interfaccia.

   ILog log1 = new ILog();    // Questo non si può fare.
   ILog log2 = new MyLog();   // Questo invece si può.

Classi Astratte
   •   Una classe astratta è una classe che non può essere istanziata (cioè non è possibile creare oggetti di questa classe).
   •   Quindi una classe astratta deve essere derivata.
   •   Una classe astratta può contenere membri astratti ma anche membri non astratti.
   •   La classe derivata dalla classe astratta, deve implementare i membri astratti facendone l'override. In alternativa potrebbe anche non implementarli tutti, ma in questo caso deve essere a sua volta astratta.

Esempio di classe Astratta
   •   In questa classe è utilizzata la parola chiave 'abstract' per indicare che la classe è astratta.
   •   Sono presenti due proprietà astratte 'ProprietaAstratta1' e 'ProprietaAstratta2' e due metodi astratti 'MetodoAstratto1' e 'MetodoAstratto2'.

   •   Sono anche presenti due proprietà non astratte 'ProprietaPrivata' e 'ProprietaPubblica' e due metodi non astratti 'MetodoPrivato' e 'MetodoPubblico'.

   abstract class ClasseAstratta
   {
       public abstract int ProprietaAstratta1 { get; set; }
       public abstract int ProprietaAstratta2 { get; set; }
       public abstract void MetodoAstratto1();
       public abstract void MetodoAstratto2();

       int ProprietaPrivata;
       public int ProprietaPubblica;
       void MetodoPrivato()
       { }
       public void MetodoPubblico()
       { }
   }

   •   La classe 'MyClass' è derivata dalla classe base 'ClasseAstratta'.
   •   In questa classe è obbligatorio definire i membri astratti della classe base. Sia le proprietà che i metodi devono avere la parola chiave 'override' pena un warning da parte del compilatore.

   class MyClass : ClasseAstratta
   {
       public override int ProprietaAstratta1 { get; set; }
       public override int ProprietaAstratta2 { get; set; }
       public override void MetodoAstratto1()
       { }
       public override void MetodoAstratto2()
       { }
   }

Differenze tra Interfacce e Classi Astratte
   •   Una classe astratta può avere dei metodi implementati, una interfaccia no.
   •   Una classe astratta può avere campi, una interfaccia no.
   •   Una classe astratta può ereditare da una interfaccia, viceversa no.