Programmare coesione e disaccoppiamento – 2

 

Proseguiamo la lettura di come programmare coesione e disaccoppiamento, in questo secondo post ti insegno a capire come scrivere classi in questa ottica. Buona lettura.

Il Controller

Nel precedente post ho accennato a due pattern GRASP per favorire l’alta coesione, il Controller e il Creator. In un’ottica di architettura a n-layer il Controller è un componente situato tra il livello Presentation e il Business e può rappresentare un caso d’uso oppure il sistema stesso.

Generalmente un Controller non fa grandi cose, gestisce messaggi e decide a chi reindirizzarli; quando questi ultimi sono numerosi, non relazionati ad un oggetto di destinazione e provengono dalla user interface, il controller è di tipo use case, altrimenti è un facade.

Questo pattern aiuta ad implementare l’alta coesione indirizzando specifici messaggi a specifici metodi; in tal modo i messaggi sono ben relazionati e focalizzati e hanno, come destinatario, un metodo ben preciso e coeso in maniera corretta.

Il Creator

Il pattern Creator risolve il problema di chi dovrebbe essere responsabile della creazione dell’istanza di una classe; anch’esso, quindi, favorisce l’alta coesione, e nello stesso tempo, rende povero l’accoppiamento tra le classi dato che ciascuna, essendo pienamente responsabile di creare determinate istanze, non necessita delle altre.

L’accoppiamento è la scrittura di classi in cui metodi dell’una hanno conoscenza dei metodi dell’altra; la conseguenza maggiormente catastrofica di tale pratica avviene in caso di modifica e di comprensione del design delle classi, vediamo a seguire qualche suggerimento.

Una delle prime attività da compiere è la eliminazione della conoscenza che un metodo di una classe ha nei confronti di un’altra; ecco un breve esempio di come NON programmare coesione nel codice:


public void GetSomething()
{
   string connString = getConnString();
   SqlConnection conn = new SqlConnection(connString);
   DataServer1 srv = new DataServer1(conn);
   int recNumber = 10;

   using (SqlDataReader reader = srv.GetWorkItemData(recNumber))
   {
      while (reader.Read())
      {
         string surname = reader.GetString(0);
         string address = reader.GetString(1);
        DoSomething(surname, address);
      }
   }
}

a prima vista sembrerebbe un ottimo esempio di implementazione di un metodo, osservate ora la seconda versione ripulita:

public void GetSomething()
{ 
   DataServer2 srv = new DataServer2();
   foreach (DataItem item in srv.GetWorkItemData(10))
   { 
      DoSomething(item);
   } 
}

nella seconda versione sono stati rimossi i riferimenti che il metodo possedeva relativamente a come accedere al db, ciò riduce la complessità, mette maggiore ordine e disaccoppia il metodo da quelli di ADO.NET.

Ecco un ottimo esempio di come programmare coesione e disaccoppiamento!

Chi vuole accedere al GetSomething (prima versione) deve creare istanze degli oggetti per la connessione a SQL e capire la struttura del DataReader restituito.

Viceversa chi vuole accedere alla seconda versione non deve fare altro che invocare un metodo che restituisce un array di oggetti tipizzati.

Infine, nella prima versione l’eventuale modifica al modo di lavorare di DataServer1 potrebbe impattare sul metodo, nella seconda versione DataServer2 potrebbe riferirsi a un tipo diverso di RDBMS senza intaccare minimamente il metodo GetSomething.

Bene, sei pronto per leggere la terza ed ultima parte del post.

 

Acquista su Amazon.it

 

🔥125
Vota questo articolo

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *