Come nominare metodi come factory?

Immagino che la maggior parte dei metodi di fabbrica inizi con create. Ma perché si chiamano " creare "? Perché non " creare ", " produrre ", " costruire ", " generare " o qualcos'altro? È solo una questione di gusti? Una convenzione? O c'è un significato speciale in "creare"?

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

Quale sceglieresti in generale e perché?

Alcuni pensieri casuali:

• "Crea" si adatta alla funzione meglio della maggior parte delle altre parole. La parola migliore successiva che mi viene in mente dalla cima della mia testa è "Costruisci". In passato, "Alloc" (allocate) avrebbe potuto essere utilizzato in situazioni simili, riflettendo la maggiore enfasi sui blocchi di dati rispetto agli oggetti in linguaggi come C.

• 'Crea' è una parola breve e semplice che ha un chiaro significato intuitivo. Nella maggior parte dei casi le persone probabilmente la scelgono solo come la prima, la più ovvia parola che viene in mente quando desiderano creare qualcosa. È una convenzione di denominazione comune e la "creazione di oggetti" è un modo comune di descrivere il processo di ... creazione di oggetti.

• 'Costruisci' è vicino, ma di solito è usato per descrivere una fase specifica nel processo di creazione di un oggetto (allocare / nuovo, costruire, inizializzare ...)

• 'Build' e 'Make' sono termini comuni per i processi relativi alla compilazione del codice, quindi hanno connotazioni diverse ai programmatori, implicando un processo che comprende molti passaggi e possibilmente molta attività del disco. Tuttavia, l'idea di una fabbrica che "costruisce" qualcosa è un'idea sensata, specialmente nei casi in cui viene costruita una struttura di dati complessa o molte informazioni separate vengono combinate in qualche modo.

• 'Genera' per me implica un calcolo che viene utilizzato per produrre un valore da un input, come generare un codice hash o un numero casuale.

• "Produci", "Genera", "Costruisci" sono più lunghi da digitare / leggere di "Crea". Storicamente i programmatori hanno preferito nomi brevi per ridurre la digitazione / lettura.

Joshua Bloch in "Effective Java" suggerisce le seguenti convenzioni di denominazione

valueOf - Restituisce un'istanza che ha, in termini vaghi , lo stesso valore dei suoi parametri. Tali fabbriche statiche sono effettivamente metodi di conversione del tipo.

di - Un'alternativa sintetica a valueOf, resa popolare da EnumSet(Articolo 32).

getInstance - Restituisce un'istanza descritta dai parametri ma non si può dire che abbia lo stesso valore. Nel caso di un singleton, getInstancenon accetta parametri e restituisce l'unica istanza.

newInstance - Like getInstance, tranne che newInstancegarantisce che ogni istanza restituita è distinta da tutte le altre.

get Type - Like getInstance, ma usato quando il metodo factory è in una classe diversa. Tipo indica il tipo di oggetto restituito dal metodo factory.

new Type - Like newInstance, ma usato quando il metodo factory è in una classe diversa. Tipo indica il tipo di oggetto restituito dal metodo factory.

Volevo aggiungere un paio di punti che non vedo nelle altre risposte.

1. Sebbene tradizionalmente "Fabbrica" ​​significhi "crea oggetti", mi piace pensarlo più in generale perché "mi restituisce un oggetto che si comporta come mi aspetto". Non dovrei sempre sapere se si tratta di un oggetto nuovo di zecca , in effetti potrebbe non interessarmene. Quindi, in casi appropriati, potresti evitare un nome "Crea ...", anche se è così che lo stai implementando in questo momento.

2. Guava è un buon repository di idee di denominazione di fabbrica. Sta diffondendo un bel stile DSL. esempi:

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

"Crea" e "crea" sono brevi, ragionevolmente evocativi e non legati ad altri schemi di denominazione che mi vengono in mente. Ho anche visto abbastanza frequentemente e sospetto che possano essere "standard di fatto". Ne sceglierei uno e lo userei coerentemente almeno all'interno di un progetto. (Guardando il mio progetto attuale, mi sembra di usare "make". Spero di essere coerente ...)

Evita "build" perché si adatta meglio al modello Builder ed evita "produce" perché evoca Producer / Consumer.

Per continuare davvero la metafora del nome "Factory" per il modello, sarei tentato dalla "fabbricazione", ma è una parola troppo lunga.

Penso che derivi da " creare un oggetto". Tuttavia, in inglese, la parola "creare" è associata alla nozione di "far nascere, come qualcosa di unico che non si evolverebbe naturalmente o che non sarebbe prodotto da processi ordinari" e "evolversi dal proprio pensiero o immaginazione, come un'opera d'arte o un'invenzione. " Quindi sembra che "creare" non sia la parola corretta da usare. "Creare", d'altra parte, significa "mettere in atto modellando o cambiando materiale, combinando parti, ecc." Ad esempio, non si crea un abito, si crea un abito (oggetto). Quindi, secondo me, "fare" con il significato di "produrre; causare l'esistenza o accadere; portare a termine "è una parola molto migliore per i metodi di fabbrica.

Mi piace il nuovo Per me

var foo = newFoo();

legge meglio di

var foo = createFoo();

Tradotto in inglese, abbiamo foo è un nuovo foo o foo è creare foo. Anche se non sono un esperto di grammatica, sono abbastanza sicuro che quest'ultimo sia grammaticalmente errato.

In parte convenzione, in parte semantica.

I metodi di fabbrica (segnalati dai tradizionali create) dovrebbero invocare costruttori appropriati. Se vedessi buildURI, presumo che implicasse un calcolo o un assemblaggio da parti (e non avrei pensato che ci fosse una fabbrica coinvolta). La prima cosa che ho pensato quando ho visto generateURIè fare qualcosa di casuale, come un nuovo link di download personalizzato. Non sono tutti uguali, parole diverse evocano significati diversi; ma la maggior parte di loro non è convenzionale.

Lo chiamerei UriFactory.Create()

Dove,

UriFactoryè il nome del tipo di classe che fornisce i metodi che creano Uriistanze.

e il Create()metodo è sovraccarico per tutte le variazioni che hai nelle tue specifiche.

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

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

Vorrei sottolineare che ho visto tutti i verbi ma prodotti in uso in alcune librerie o altro, quindi non definirei creare una convenzione universale.

Ora, creare suona meglio per me, evoca il significato preciso dell'azione.

Quindi sì, è una questione di gusti (letterari).

Personalmente mi piace instantiatee instantiateWith, ma è solo per le mie esperienze di Unità e Obiettivo C. Le convenzioni di denominazione all'interno del motore Unity sembrano ruotare intorno alla parola instantiateper creare un'istanza tramite un metodo factory e l'obiettivo C sembra withindicare quali sono i parametri. Funziona davvero bene solo se il metodo è nella classe che verrà istanziata (e in linguaggi che consentono il sovraccarico del costruttore, questo non è tanto una "cosa").

Anche il semplice vecchio Obiettivo C initWithè anche un buon affare!

Il metodo di fabbrica non determina il nome del metodo. Puoi avere tutti i metodi che desideri nella tua fabbrica, a condizione che tutti restituiscano l'oggetto della stessa famiglia.

Per maggiori dettagli, visita l'URL http://xeon2k.wordpress.com