Conseils pour écrire des interfaces fluides en C # 3

Question

Je suis après quelques bons conseils pour couramment interfaces en C#. Je suis en train d'apprendre sur moi-même, mais impatient d'entendre ce que les autres pensent en dehors des articles que je lis. En particulier, je suis après:

1. quand est couramment trop?
2. existe-il des modèles couramment?
3. ce qui est en C# qui fait couramment des interfaces plus à l'aise (par exemple, les méthodes d'extension)
4. est un complexe d'interface fluide encore couramment?
5. refactoring pour arriver à une interface fluide ou refactoring existant interface fluide
6. tout les bons exemples que vous avez travaillé avec ou pourrait recommander?

Si vous pouviez poster une astuce ou une pensée, ou que ce soit par la poste. Je veux voir comment ils se voté, trop.

Je vous remercie à l'avance.

Answer 1

Le plus grand défi que j'ai connu en tant que consommateur de fluent interfaces est que la plupart d'entre eux ne sont pas vraiment couramment intefaces -- au lieu de cela, ils sont vraiment des exemples de ce que j'ai tendance à qualifier de " lisible interfaces.

Une interface fluide implique que son principal objectif est de le rendre facile d'en PARLER alors que la lisibilité de l'interface implique que son principal objectif est d'être facile à LIRE. Plus couramment interfaces ont tendance à être ridiculement difficile de code, mais à l'inverse incroyablement facile à LIRE plus tard par d'autres.

Assert().That().This(actual).Is().Equal().To(expected).
    Except().If(x => x.GreaterThan(10));

...est beaucoup plus facile à lire plus tard que c'est pour écrire dans le code!

Answer 2

Sur le 4ème point;

Oui, je pense que pour une interface fluide peut encore être à l'aise.

Je pense que couramment les interfaces sont en quelque sorte un compromis. (bien qu'un bon!) Il y a eu beaucoup de recherches sur l'aide de la langue naturelle pour la programmation et plus généralement de la langue naturelle n'est pas assez précis pour exprimer des programmes.

Couramment les interfaces sont construits de façon à écrire comme un langage de programmation, seulement un petit sous-ensemble de ce que vous pouvez vous exprimer dans une langue naturelle est autorisé, mais ils se lisent comme un langage naturel.

Si vous regardez rhino se moque par exemple l'écriture de la partie a été compliqué par rapport à un fonctionnement normal de la bibliothèque. Je m'a pris plus de temps pour apprendre principalement en raison de la fluidité de l'interface, mais il rend le code beaucoup plus facile à lire. Parce que les programmes sont généralement écrites qu'une seule fois et de lire beaucoup plus que une fois que c'est un bon compromis.

Donc, pour qualifier mon point de vue un peu. Une interface fluide qui est complexe à écrire, mais facile à lire, peut encore être à l'aise.

Answer 3

Moq cache des méthodes non répétées telles que equals, ToString et ainsi de suite pour rendre leur interface fluide encore plus facile à utiliser.

Masquer l'objet système est un article expliquant les avantages de cette opération.

Answer 4

Et sur votre 2ème et 3ème question;

Trois couramment des modèles j'ai remarqué

La première utilise l'instruction using C# 2.0) pour exécuter du code dans un certain contexte, par exemple:

using(var transaction = new Transaction())
{
  // ..
  // ..
}

Il utilise le constructeur et le broyeur de Transaction pour régler une transaction, puis exécute le code dans ce contexte.

La deuxième est presque le même, mais avec lambda, c'est beaucoup utilisé dans les Rhino se moque par exemple.

(new Transaction()).Run( () => mycode(); );

Le plus connu interface fluide est d'utiliser des types de retour à la chaîne des appels de méthode. La plupart des méthodes de retour de ce que vous pouvez de la chaîne d'appels sur le même objet. Mais vous pouvez également retourner des objets différents à modifier le contexte en fonction de la méthode appelée. Si vous avez un objet qui ne peut s'exécuter dans une transaction (désolé peut pas penser à un autre exemple), vous pouvez lui donner un StartTransaction méthode qui renvoie un initialisé transaction où vous pouvez exécuter exécuter et stoptransaction, en pseudo-code:

class Runner
{
  Transaction StartTransaction()
  {
    return new Transaction(this);
  }
}

class Transaction
{
  Transaction Run()
  Transaction StopTransaction()
}

d'où l'appel ressemble

var runner = new Runner();
runner
  .StartTransaction()
  .Run()
  .StopTransaction();

Bien sûr, vous devez ajouter toutes sortes d'erreurs.