J'ai récemment suggéré qu'une méthode de chaînage soit implémentée pour une certaine classe dans un certain projet afin que la lisibilité du code puisse être améliorée. J'ai obtenu une réponse «les interfaces fluides ne devraient pas être implémentées uniquement pour des raisons de commodité, mais pour la sémantique» et ma proposition a été rejetée. J'ai répondu que je ne proposais pas une interface fluide mais une méthode de chaînage (les deux peuvent être confondues , lues en bas) pour améliorer la lisibilité et le confort de codage, la suggestion a été rejetée à nouveau.

Quoi qu'il en soit, cela m'a fait penser que je pourrais peut-être encourir une mauvaise pratique en renvoyant toujours "ceci" dans des méthodes qui ne sont censées rien renvoyer (par exemple, les setters).

Ma question est la suivante: l'application de la convention précédente peut-elle être considérée comme une mauvaise pratique ou un abus?, Pourquoi?. Je ne pense pas qu'il y ait des inconvénients de performances, ou y en a-t-il?.

Non

Comme le souligne Kent Beck , le code est lu beaucoup plus souvent qu'il n'est écrit.

Si le chaînage de méthodes rend votre code plus lisible, utilisez le chaînage de méthodes.

Oui, il y a des inconvénients

Un code facile à lire est bon, mais méfiez-vous également de ce qu'il communique . Lorsque les méthodes d'un objet retournent toujours l'objet, il communique deux ou trois choses:

1. J'ai besoin d'une configuration avancée qui n'est pas nécessairement évidente dans quel ordre les choses doivent être définies ou configurées
2. Chaque appel de méthode suivant s'appuie sur le dernier

Cas d'utilisation valide: requêtes de base de données ad hoc

Les bibliothèques de classes existent dans la plupart des langages qui vous permettent d'interroger une base de données sans recourir à du code SQL codé en dur. Prenez l'exemple d'Entity Framework pour .NET:

DBContext db = new DBContext();
List<Post> posts = db.Posts
    .Where(post => post.Title.Contains("Test"))
    .OrderBy(post => post.DateCreated)
    .ToList();

Il s'agit d'une interface fluide où chaque appel de méthode suivant s'appuie sur le précédent. La lecture de ces appels est logique dans le contexte de l'interrogation d'une base de données.

Cas d'utilisation non valide: sucre syntaxique pour la définition des propriétés

Maintenant, utilisons le même modèle avec la Postclasse:

public class Post
{
    public string Title { get; set; }
    public DateTime DateCreated { get; set; }
    public string Body { get; set; }

    public Post SetTitle(string title)
    {
        Title = title;

        return this;
    }

    public Post SetDateCreated(DateTime created)
    {
        DateCreated = created;

        return this;
    }

    public Post SetBody(string body)
    {
        Body = body;

        return this;
    }
}

Voyons maintenant comment vous utiliseriez cette classe:

Post post = new Post()
    .SetTitle("Test")
    .SetDateCreated(DateTime.Now)
    .SetBody("Just a test");

Lorsque je vois ce code, je pose immédiatement cette question: "Après avoir appelé SetBody, interroge-t-il la base de données? Dois-je appeler une autre méthode pour dire" J'ai terminé? ""

Que communiquent les appels de méthode chaînés au code à l'aide de la Postclasse?

1. J'ai une configuration compliquée
2. Chaque appel de méthode s'appuie sur le précédent

Est-ce vraiment vrai? Non. La Postclasse n'a pas de configuration compliquée. La définition du titre, de la date de création et du corps ne s'appuie pas l'un sur l'autre vers un objectif final plus compliqué. Vous avez écrasé une cheville carrée dans un trou rond.

L'inconvénient du chaînage de méthode auto-référentiel est que vous communiquez que plusieurs appels de méthode sont nécessaires pour faire quelque chose, et que chaque appel s'appuie sur le dernier. Si ce n'est pas le cas, le chaînage de méthode peut être communiquer la mauvaise chose à d'autres programmeurs.

Lorsque vos collègues ont dit:

Les interfaces fluides ne doivent pas être implémentées uniquement pour des raisons de commodité, mais pour la sémantique

Ils étaient absolument corrects. Une interface fluide, ou un chaînage de méthodes, communique quelque chose en soi qui pourrait ne pas être vrai.

Le principal inconvénient est une perte de clarté. Par exemple:

x.foo();
x.bar();
x.baz();

Puisqu'aucune de ces instructions ne retourne une valeur (ou si elles le font, elle a été ignorée), elles ne peuvent être utiles que si elles produisent des effets secondaires. Comparez cela à:

x.foo()
 .bar()
 .baz();

Tout d' abord, on ne sait pas que baret bazfonctionnent sur des objets du même type que x, à moins que vous savez pertinemment que xla classe « est la seule classe avec ces méthodes. Même si c'est le cas, il n'est pas clair que les méthodes fonctionnent xou les nouveaux objets.

La mise en évidence des parties du code qui ont des effets secondaires est utile, car vous devez suivre ces effets secondaires pour raisonner sur le programme. Vous devez peser la perte potentielle de clarté par rapport au gain potentiel de facilité d'écriture de code, mais considérez également que le code est lu plus qu'il n'est écrit.

Tenez compte de tous les éléments stylistiques des langages de programmation (par opposition au langage machine à codage manuel), et cela affaiblit l'argument «sémantique et non commodité».

Une grande partie de ce que nous faisons en tant qu'ingénieurs fournit la commodité autour de la sémantique.