In questo capitolo parleremo del Polimorfismo, ereditarietà ed Overloading. 
Una classe eredita un'altra classe mediante  Inherits (che in inglese significa 'Eredita'), con la seguente sintassi: 

class ClasseBase
{

    //Membri della classe

}


class Eredita : ClasseBase
{

   //Membri della classe Eriditata e della nuova classe

}

Ereditando una classe Base avremo dopo tutti i mebri della classe base nella nuova classe ereditata. 
Cambiando argomento e spostandoci sul polimorfismo chi chiederemo cos'è. 
Il polimorfismo permette di ridefinire nelle classi derivate. 
Mentre l'overloading e applicabile unicamente sui membri della classe stessa. 

un piccolo esempio 

Ereditando una classe Base avremo dopo tutti i mebri della classe base nella nuova classe ereditata. 
Potendo anche accedere alle sue relative funzioni, e magari virtualizzare un void e successivamente modificarne l'esecuzione.
Ma come funzina esattamente?

Presumiamo che abbiamo una libreria, e che l'autore della libreria vuole creare un controllo, e dà accesso all'utente finale la possibilità
di modificare alcuni funzionamenti a proprio piacimento.
Breve esempio

Il programmatore della libreria, crea un metodo interno virtuale che dà unicamente la possibilità di addizionare due valori.

public class Libreria
{

  private int totale;
  public virtual void Calcola(int num1,int num2)
  {
      totale = num1 + num2;
   }

}

Avendo un void di tipo Virtual nella libreria possiamo ereditare la classe con la suddetta funzione e modificarne il comportamento.

public class Programma : Libreria
{

  public int totale;
  public override void Calcola(int num1,int num2)
  {
      totale = (num1 + num2) * 2;
   }


}

Esempio di overloading con Polimorfismo

In questo caso, la Libreria ci dà si la possibilità di effettuare un calcolo.
Ma non dà la possibilità di accedere alla variabile totale.
Quindi non potremmo sapere il risultato del calcolo.
Ma l'autore della libreria ha pensato bene di rendere il metodo Calcola Virtuale in modo da poter fare un overload.
e poter gestire meglio quel void.

public class Libreria
{

  private int totale;
 
  public virtual void Calcola(int num1,int num2)
  {
     totale = num1 + num2;
  }

  public void Stampa()
  {
     Console.WriteLine(totale.ToString());
  }


}

public class Strumento : Libreria
{

   public int Totale {get; set;}

   public override void Calcola(int num1,int num2)
   {
      Totale = (num1 + num2) * 2;
   }

   
}

Richiamando la funzione

class Program
{
    static void Main(string[] args)
    {
       Libreria lib = new Libreria();
       Strumento strum = new Strumento();

        lib.Calcola(5,5); //Calcola ma non da un risultato a noi.
         
        //Calcola tramite la funzione ereditata ed del void Calcola
        //modificato 

        strum.Calcola(5,5);
        int risultato = strum.Totale;      
       
        Console.ReadKey();
    }
 }

Cos'è un Overload invece?

Un overload ci permette di avere lo stesso motodo ma con diversi paremetri.
Un esempio è:
Poniamo di dover scrivere sulla console con un solo void sia unicamente del testo, che unicamente dei numeri.
Ma utilizzando un solo void. Come si fà?

//Esempio di overload


//Questo metodo accetta solo un intero
public void Stampa(int numero)
{
    Console.WriteLine(numero.ToString());
}


//Questo metodo accetta solo una stringa
public void Stampa(string valore)
{
   Console.WriteLine(valore);
}

In questo modo, possiamo usare lo stesso void ma inviare valori nel parametro diverso esempio:

Stampa(10);

Stampa("Ciao");