Non commentare il codice, rendilo più leggibile con le Fluent Interface

Ad ognuno di noi sarà capitato almeno una volta di leggere una porzione di codice e di non riuscire a capirne la logica. Tra le cause oltre al cattivo design c’è quasi sempre la mancanza di commenti o di documentazione. Ma quanti di noi commentano il codice che scrivono? Intendiamoci è una buona regola commentare il codice, ma è un’attività talmente noiosa che diventa inutile se poi non manteniamo il commento aggiornato.
Vediamo allora come applicando le “Fluent Interface” possiamo scrivere del codice che si commenta da solo!

Una interfaccia è “fluente” quando ci consente di rendere il codice implementativo leggibile come le righe di un romanzo oppure come le strofe di una poesia. Tale caratteristica non è soggettiva, ma si può ottenere facilmente partendo dalla tecnica del method chaining.

Il method chaining, ovvero la possibilità di concatenare le chiamate ai metodi di una interfaccia, si ottiene definendo come valore di ritorno l’istanza corrente della classe a cui appartiene il metodo.

Con un po’ di codice tutto sarà più chiaro. Vediamo quindi un esempio di interfaccia non “fluente” che riguarda la prenotazione di un biglietto ferroviario. Partiamo con la classe Train:
namespace FluentInterface.Model.NoFluent
{
    using System;
    using System.Text;

    public class Train
    {
        public string Number { get; set; }

        public string DepartureStation { get; set; }

        public string Destination { get; set; }

        public DateTime DepartureDate { get; set; }

        public int Class { get; set; }

        public Train(){ }

        public Train(string number, 
                     string departureStation, string destination, 
                     DateTime departureDate, int _class)
        {
            this.Number = number;
            this.DepartureStation = departureStation;
            this.Destination = destination;
            this.DepartureDate = departureDate;
            this.Class = _class;
        }
    }
}

Nel codice cliente andiamo poi a prenotare il biglietto per un particolare treno:

bookingService.PlaceBookingFor(
            new Train("9513", 
                      "Milano C.le", 
                      "Roma Termini", 
                      DateTime.Parse("2010/02/12 8:20"), 1)
);

Come possiamo notare il codice non è per niente leggibile, dobbiamo infatti ricorrere alla definizione del costruttore della classe per capire il significato dei parametri passati.

Grazie agli object initializer introdotti con la versione 3.0 di C# il codice si fa più chiaro, ma rimane ancora pesante da leggere:
bookingService.PlaceBookingFor(
    new Train()
    { 
      Number = "9513",
      DepartureStation = "Milano C.le",
      Destination = "Roma Termini",
      DepartureDate = DateTime.Parse("2010/02/12 8:20"),
      ClassNumber = 1
    }   
);

Vediamo quindi come una interfaccia “fluente” può rendere questo codice più leggibile:

namespace FluentInterface.Model.Fluent
{
    using System;
    using System.Text;

    public enum Class 
    {
        First = 1,
        Second = 2,
        Third = 3
    }

    public class Train
    {
        public string Number { get; set; }

        public string DepartureStation { get; set; }

        public string Destination { get; set; }

        public DateTime DepartureDate { get; set; }

        public int ClassNumber { get; set; }

        public Train(){ }

        public Train(string number, 
                     string departureStation, string destination, 
                     DateTime departureDate, int classNumber)
        {
            this.Number = number;
            this.DepartureStation = departureStation;
            this.Destination = destination;
            this.DepartureDate = departureDate;
            this.ClassNumber = classNumber;
        }

        #region Fluent Interface
        public Train Nr(string number)
        {
            this.Number = number;
            return this;
        }

        public Train From(string departureStation)
        {
            this.DepartureStation = departureStation;
            return this;
        }

        public Train To(string destination)
        {
            this.Destination = destination;
            return this;
        }

        public Train DepartureAt(DateTime departureDate)
        {
            this.DepartureDate = departureDate;
            return this;
        }

        public Train DepartureAt(string departureDate)
        {
            this.DepartureDate = DateTime.Parse(departureDate);
            return this;
        }

        public Train In(Class _class)
        {
            this.ClassNumber = (int)_class;
            return this;
        }
        #endregion
    }
}

Vediamo come cambia il nostro codice cliente per quanto riguarda la prenotazione di un biglietto ferroviario:

bookingService.PlaceBookingFor(new Train().Nr("9513")
                                          .From("Milano C.le")
                                          .To("Roma Termini")
                                          .DepartureAt("12/2/09 8:20")
                                          .In(Class.First));

Possiamo migliorare ancora trasformando il metodo Nr in una “static factory”, ovvero implementando al suo interno la creazione di una istanza della classe Train, così:

public static Train Nr(string number)
{
   Train train = new Train();
   train.Number = number;
   return train;
}

La differenza rispetto al codice di prima è minima, ma evidente:

bookingService.PlaceBookingFor(Train.Nr("9513")
                                    .From("Milano C.le")
                                    .To("Roma Termini")
                                    .DepartureAt("12/02/2009 8:20")
                                    .In(Class.First));

In conclusione ci sono molti modi per aiutare noi stessi e altri programmatori a capire che cosa fa il nostro codice, il più importante di tutti rimane sempre il commento, ma le fluent interface sono un valido alleato per combattere le lunghe sedute davanti al reflector!