Comment nommer des méthodes similaires à une usine?

Je suppose que la plupart des méthodes de type usine commencent par create. Mais pourquoi sont-ils appelés « créer »? Pourquoi pas « faire », « produire », « construire », « générer » ou autre chose? Est-ce seulement une question de goût? Une convention? Ou y a-t-il une signification particulière dans «créer»?

createURI(...) 
makeURI(...)
produceURI(...)
buildURI(...)
generateURI(...)

Lequel choisiriez-vous en général et pourquoi?

Quelques pensées aléatoires:

• «Créer» correspond mieux à la fonctionnalité que la plupart des autres mots. Le deuxième meilleur mot auquel je puisse penser est «Construct». Dans le passé, 'Alloc' (allocate) aurait pu être utilisé dans des situations similaires, reflétant la plus grande importance accordée aux blocs de données qu'aux objets dans des langages comme C.

• «Créer» est un mot court et simple qui a une signification claire et intuitive. Dans la plupart des cas, les gens le choisissent probablement comme le premier mot le plus évident qui leur vient à l'esprit lorsqu'ils souhaitent créer quelque chose. C'est une convention de dénomination courante, et la «création d'objets» est une manière courante de décrire le processus de ... création d'objets.

• 'Construct' est proche, mais il est généralement utilisé pour décrire une étape spécifique du processus de création d'un objet (allouer / nouveau, construire, initialiser ...)

• «Construire» et «Créer» sont des termes courants pour les processus relatifs à la compilation de code, ils ont donc des connotations différentes pour les programmeurs, ce qui implique un processus qui comprend de nombreuses étapes et peut-être beaucoup d'activité de disque. Cependant, l'idée d'une usine "construisant" quelque chose est une idée sensée - en particulier dans les cas où une structure de données complexe est construite, ou de nombreuses informations séparées sont combinées d'une manière ou d'une autre.

• «Générer» pour moi implique un calcul qui est utilisé pour produire une valeur à partir d'une entrée, comme la génération d'un code de hachage ou d'un nombre aléatoire.

• «Produire», «Générer», «Construire» sont plus longs à taper / lire que «Créer». Historiquement, les programmeurs ont privilégié les noms courts pour réduire la saisie / lecture.

Joshua Bloch dans "Effective Java" suggère les conventions de dénomination suivantes

valueOf - Renvoie une instance qui a, en gros, la même valeur que ses paramètres. De telles usines statiques sont en fait des méthodes de conversion de type.

of - Une alternative concise à valueOf, popularisée par EnumSet(Point 32).

getInstance - Renvoie une instance décrite par les paramètres mais dont on ne peut pas dire qu'elle a la même valeur. Dans le cas d'un singleton, getInstance ne prend aucun paramètre et renvoie la seule instance.

newInstance - Like getInstance, sauf que newInstancegarantit que chaque instance renvoyée est distincte de toutes les autres.

get Type - Comme getInstance, mais utilisé lorsque la méthode de fabrique est dans une classe différente. Type indique le type d'objet renvoyé par la méthode de fabrique.

new Type - Comme newInstance, mais utilisé lorsque la méthode de fabrique est dans une classe différente. Type indique le type d'objet renvoyé par la méthode de fabrique.

Je voulais ajouter quelques points que je ne vois pas dans les autres réponses.

1. Bien que traditionnellement «Usine» signifie «crée des objets», j'aime à penser plus largement que «me renvoie un objet qui se comporte comme je l'attends». Je ne devrais pas toujours avoir à savoir si c'est un tout nouvel objet , en fait je m'en fiche. Donc, dans les cas appropriés, vous pouvez éviter un nom «Créer ...», même si c'est ainsi que vous l'implémentez en ce moment.

2. Guava est un bon référentiel d'idées de dénomination d'usine. Il popularise un joli style DSL. exemples:

   Lists.newArrayListWithCapacity(100);
   ImmutableList.of("Hello", "World");
   

«Créer» et «faire» sont courts, raisonnablement évocateurs et ne sont pas liés à d'autres modèles de dénomination auxquels je peux penser. J'ai également vu les deux assez fréquemment et je soupçonne qu'il s'agit peut-être de "normes de facto". J'en choisirais un et l'utiliserais de manière cohérente au moins dans un projet. (En regardant mon propre projet actuel, je semble utiliser "make". J'espère que je suis cohérent ...)

Évitez de «construire» car il correspond mieux au modèle Builder et évitez de «produire» car il évoque le producteur / consommateur.

Pour vraiment continuer la métaphore du nom "Factory" du motif, je serais tenté par "manufacture", mais c'est un mot trop long.

Je pense que cela découle de « créer un objet». Cependant, en anglais, le mot «créer» est associé à la notion de «faire naître, comme quelque chose d'unique qui n'évoluerait pas naturellement ou qui n'est pas fait par des processus ordinaires», et «d'évoluer à partir de sa propre pensée ou l’imagination, comme œuvre d’art ou invention. » Il semble donc que «créer» n'est pas le mot approprié à utiliser. «Faire», en revanche, signifie «faire exister en façonnant ou en changeant de matière, en combinant des pièces, etc.» Par exemple, vous ne créez pas de robe, vous fabriquez une robe (objet). Donc, à mon avis, «faire» en signifiant «produire; cause d'exister ou de se produire; provoquer »est un mot bien meilleur pour les méthodes d'usine.

J'aime nouveau. Tome

var foo = newFoo();

lit mieux que

var foo = createFoo();

Traduit en anglais, nous avons foo est un nouveau foo ou foo est create foo. Bien que je ne sois pas un expert en grammaire, je suis presque sûr que ce dernier est grammaticalement incorrect.

En partie convention, en partie sémantique.

Les méthodes d'usine (signalées par le traditionnel create) doivent invoquer les constructeurs appropriés. Si je voyais buildURI, je supposerais que cela impliquait un calcul ou un assemblage à partir de pièces (et je ne pense pas qu'il y ait une usine impliquée). La première chose à laquelle j'ai pensé en voyant generateURIest de créer quelque chose de aléatoire, comme un nouveau lien de téléchargement personnalisé. Ce ne sont pas tous les mêmes, des mots différents évoquent des significations différentes; mais la plupart d'entre eux ne sont pas conventionnels.

Je l'appellerais UriFactory.Create()

Où,

UriFactoryest le nom du type de classe qui fournit des méthodes qui créent des Uriinstances.

et la Create()méthode est surchargée pour autant de variations que vous avez dans vos spécifications.

public static class UriFactory
{
    //Default Creator
    public static UriType Create() 
    {
    }

    //An overload for Create()
    public static UriType Create(someArgs) 
    {
    }
}

Je ferais remarquer que j'ai vu tous les verbes mais produire en cours d'utilisation dans une bibliothèque ou une autre, donc je n'appellerais pas create être une convention universelle.

Maintenant, créer me sonne mieux, évoque le sens précis de l'action.

Alors oui, c'est une question de goût (littéraire).

Personnellement, j'aime instantiateet instantiateWith, mais c'est juste à cause de mes expériences Unity et Objective C. Les conventions de dénomination à l'intérieur du moteur Unity semblent tourner autour du mot instantiatepour créer une instance via une méthode de fabrique, et Objective C semble aimer withindiquer ce que sont les paramètres. Cela ne fonctionne vraiment bien que si la méthode est dans la classe qui va être instanciée (et dans les langages qui permettent la surcharge du constructeur, ce n'est pas vraiment une «chose»).

Tout simplement le vieil objectif C initWithest aussi un bon!

La méthode d'usine ne dicte pas le nom de la méthode. Vous pouvez avoir autant de méthodes que vous le souhaitez dans votre usine, à condition qu'elles renvoient toutes l'objet de la même famille.

Pour plus de détails, visitez l'url http://xeon2k.wordpress.com