Nom de l'interface: préfixe «Can-» vs suffixe «-Able»

Il est courant d'utiliser '-able' comme suffixe pour les interfaces, par exemple

Serializable Printable Enumerable Drinkable Shootable Rotatable

Je pensais que «Can-» pourrait mieux parce qu'il pourrait être plus descriptif. Oui, il est plus verbeux et ajoute du bruit au nom de l'interface. En particulier, les verbes passifs peuvent être utilisés.

Par exemple, 1 Tirable signifie que l'objet est capable de tirer (une arme à feu pourrait implémenter cela), ou cela signifie-t-il qu'il peut être tiré (une planche cible pourrait implémenter cela). Avec le préfixe 'Can-', le premier serait "CanShoot" et le second serait "CanBeShotAt" ou "CanShootAt".

Par exemple: 2 Un document 'CanBePrinted' et une imprimante 'CanPrint'

Ou devrions-nous nous en tenir à «-Able» et laisser la documentation fournir le contexte?

Des opinions.

Peut-être voulez-vous pouvoir?

Quelques exemples de .Net:

NetworkStream.Readable
NetworkStream.Writable
Stream.CanRead
Stream.CanWrite
Type.IsSerializable

Il ne semble pas y avoir de norme uniforme. Allez avec ce qui se lit bien.

if (document.IsPrintable && printer.CanPrint) { printer.Print(document) }

EDIT: Comme indiqué, la question concernait les interfaces, pas les propriétés.

Dans ce cas, je ne trouve aucune interface nommée Can-. Les interfaces ont tendance à toujours utiliser -able. Je serais d'accord avec cette terminologie. Une méthode peut demander comme paramètre a ISerializable objectou IPrintable document. Demander un ICanBeSerialized objectou un ICanBePrinted documentest très difficile à lire.

De l'autre côté, l'imprimante, je suggère simplement d'appeler l'interface IPrinter. Votre méthode demandera un IPrinter device.

Lisez à haute voix la signature de méthode ci-dessous. (Personnellement, je considère que le préfixe "I" est silencieux.) Est-ce que cela se lit bien? Est-ce que ça sonne bien?

void PrintDocument(IPrinter device, IPrintable document)
{
    device.Print(document)
}

Grammaticalement parlant, "canFoobar" est un prédicat, tandis que "Foobarable" est un adjectif ou un nom (généralement un nom dans le contexte d'une API).

Notez également la différence subtile: -able implique un rôle passif au nom auquel il est appliqué, c'est-à-dire que si quelque chose est foobarable, alors il peut être foobaré par autre chose; can- implique un rôle actif, c'est-à-dire que si Something canFoobar, alors il peut foobar autre chose. Ou, sous un angle différent: si A peut foobar B, alors A.canFoobar()et B is Foobarable.

En termes d'expressivité OOP, j'associerais des prédicats à des méthodes ou des propriétés, tandis que les noms sont des classes ou des interfaces. Alors:

instance.canFoobar();

class Something implements Foobarable { ... }

Personnellement, je m'en tiendrai à la version -able. Voici ma raison: la plupart (tous?) Des éditeurs graphiques suggèrent des identifiants basés sur ce que vous avez tapé. Bien que certains d'entre eux soient suffisamment «intelligents» pour effectuer également des recherches dans les identifiants, certains ne proposent que des débuts de recherche d'identifiants.

Pour accélérer la saisie, vous souhaitez raccourcir la liste des identifiants suggérés avec le moins de touches possible. Plus les identifiants ont le même début, par exemple «ICan-», plus vous devrez taper de caractères.

Si vous pensez que ce n'est pas un problème dans votre cas, c'est parfait et je recommanderais d'utiliser d'autres critères pour choisir une convention de dénomination. Dans certains cas, par exemple dans notre équipe, nous préférons les identifiants qui distinguent le moins de frappes possible.

En dehors de cela, je recommanderais d'utiliser la convention de dénomination qui rend votre code le plus compréhensible pour ceux qui travaillent sur le projet. Ayez une conversation au sein de votre équipe. Il n'y a pas de bien ou de mal en tant que tel. Juste des conventions qui fonctionnent et des conventions qui fonctionnent moins.

N'oubliez pas que de bons outils de refactoring vous permettent de renommer les choses aussi souvent que vous le souhaitez. Il est donc facile d'expérimenter différentes approches.

Il est clair que le préfixe et le suffixe sont des choix presque évidents pour différents types d'actions ou plutôt, différentes directions d'une action.

Cependant, l'utilisation et les préférences actuelles peuvent être incohérentes pour de nombreuses raisons.

L'action est exécutée par l'objet:
CanShoot -> Il tire quelque chose sur
CanFly -> Il vole
CanChange -> Il change

L'action est effectuée sur l'objet:
Lisible -> Vous pouvez le lire
Écrivable -> Vous pouvez l'écrire (sur)
Imprimable -> Vous pouvez l'imprimer

Bien que cela ne soit pas une règle ou même nécessairement logique, cela aide à adopter la convention et à maintenir la cohérence d'utilisation dans la dénomination des variables.

Je pense que vous voudrez peut-être faire la distinction entre la capacité et la permission. Même si un élément est susceptible d'être sérialisé Serializableet CanSerializeimplique qu'il existe également des problèmes d'autorisation (ou peut-être un manque d'espace disque) et que vous devrez peut-être prendre en compte MaySerialize. Laisser les choses en place ~ableélimine le besoin de distinguer entre canet may.

Lorsque je sous-classe / implémente des interfaces, je pense que la règle générale est que vous devriez pouvoir dire "B est un A" (où B implémente A). Il ne semble pas juste de dire:

A Documentest unCanBePrinted

Mais cela semble juste (ou du moins mieux) de dire:

A Documentest unPrintable

Je pense que Xable au niveau grammatical et conventionnel est meilleur pour les noms d'interfaces, tandis que IsX, CanX, DoesX sont meilleurs pour les noms de propriétés.

Depuis MSDN:

"Nommez les propriétés booléennes avec une phrase affirmative (CanSeek au lieu de CantSeek). Vous pouvez également préfixer les propriétés booléennes avec Is, Can ou Has, mais uniquement là où cela ajoute de la valeur." http://msdn.microsoft.com/en-us/library/ms229012.aspx

À mon avis, la variante "-able" est beaucoup plus lisible que votre "CanDoSomething" proposé qui impose beaucoup plus de bosses de chameau.

Dans Scala, *Ableest utilisé pour les interfaces, mais Can*est utilisé pour le modèle de classe de type. Essentiellement, pour pouvoir appeler certaines méthodes, une valeur implicite d'un certain type doit exister dans la portée. Le nom de ce type est parfois précédé du préfixe Can.