Pagina personale di:
Carlo Vecchio
appunti di C#, R, SQL Server, ASP.NET, algoritmi, numeri
Vai ai contenuti

C# - Classi e oggetti in C#

C#

Definizione di una classe
   •   Per definire di una classe:

   class nome_classe
   {
       
// corpo della classe
       
// contiene proprietà e metodi
   }


Creazione di oggetti
   •   Creare un oggetto dalla classe:

   nome_classe identificatore_oggetto = new nome_classe();

   •   In questo caso è stato utilizzato il costruttore predefinito, senza parametri.

Costruttore e distruttore della classe
   •   Il costruttore
della classe è un metodo speciale che ha lo stesso nome della classe. Viene eseguito ogni volta che viene istanziato un oggetto.
   •   Possono esserci più costruttori per una classe: quello predefinito non accetta parametri; eventuali altri costruttori accettano parametri diversi tra loro per il tipo e/o la quantità. Questo concetto si chiama ‘overload dei costruttori’
.
   •   Anche il costruttore può essere public o private; se si lascia per esempio un solo costruttore public con parametri, si può obbligare il programmatore ad utilizzare solo quello.
   •   Aggiungere codice per il costruttore della classe:

   public nome_classe()
   {
       
// corpo del costruttore
   }


   •   Aggiungere codice per il distruttore
della classe:

   ~nome_classe()
   {
       // corpo del distruttore

   }


   •   Generalmente non è necessario scrivere codice per il distruttore.

Classi parziali
   •   Le classi parziali
sono classi il cui codice viene spezzato su più file.
   •   Per realizzare una classe parziale basta aggiungere la parola chiave ‘parzial’
.
   •   In un file:

   parzial class MyClass
   {
       ...
   }


   •   In un altro file:


   parzial class MyClass
   {
       ...
   }


Esempio: classe Point con diverse sintassi
   •   Esempio di definizione della classe ‘Point’:

   class Point
   {
       
public int x;
       
public int y;
   }


   •   Definizione della stessa classe, ma ora vengono salvate le proprietà in variabili locali:

   class Point
   {
       
int _x;
       
int _y;
       
public int x
       {
           
get { return _x; }
           
set { _x = value; }
       }
       
public int y
       {
           
get { return _y; }
           
set { _y = value; }
       }
   }

   •   Da C# 3.0, la sintassi precedente può essere abbreviata con la seguente (il compilatore provvede in questo caso a definire autonomamente anche la variabile privata):

   class Point
   {
       
public int x { get; set; }
       
public int y { get; set; }
   }

   •   Creazione di due oggetti:

   Point StartPoint = new Point();
   
Point EndPoint = new Point();

Esempio: classe Circle
   •   Esempio di definizione della classe ‘Circle’ con una proprietà e due metodi:

   class Circle
   {
       
public double radius;
       
public double GetArea()
       {
           
return System.Math.PI * radius * radius;
       }
       
public double GetCirconf()
       {
           
return System.Math.PI * 2 * radius;
       }
   }


   •   Utilizzo della classe ‘Circle’:

   Circle c1 = new Circle();
   c1.radius = 3;
   System.
Console.WriteLine(c1.GetArea());
   System.
Console.WriteLine(c1.GetCirconf());
   System.
Console.ReadLine();   

Classe con più costruttori
   •   Una classe può avere nessuno, uno o più costruttori.
   •   Non è necessario scrivere il codice per un costruttore: se non scritto esplicitamente, C# ne fornisce uno internamente senza parametri.
   •   I vari costruttori devono differire nella 'firma' (cioè nella quantità e nel tipo di parametri).
   •   Un costruttore può chiamare il codice di un altro costruttore, come nell'esempio seguente.

   class Persona
   {
       
string _nome;
       
string _cognome;

       
// Proprietà.
       
public string Nome
       {
           
get { return _nome; }
           
set { _nome = value; }
       }
       
public string Cognome
       {
           
get { return _cognome; }
           
set { _cognome = value; }
       }

       
// Costruttore 1.
       
public Persona(string nome, string cognome)
       {
           _nome = nome;
           _cognome = cognome;
       }
       
// Costruttore 2.
       
public Persona() : this("Nessun nome", "Nessun cognome")
       {
       }
   }

   •   Come si vede, il secondo costruttore richiama il codice del primo costruttore.

© 2020 Carlo Vecchio
Torna ai contenuti