Come e perché decidere tra i metodi di denominazione con i prefissi "ottieni" e "trova"

Uso Get quando so che il tempo di recupero sarà molto breve (come in una ricerca da una tabella hash o btree).

Find implica un processo di ricerca o un algoritmo computazionale che richiede un periodo di tempo "più lungo" per eseguire (per un valore arbitrario di più lungo).

Direi che find potrebbe fallire ma get non dovrebbe.

Per citare una conversazione che ho spesso con i miei figli:

me: Hey kid! Go find me some batteries

kid: But where are they?

me: That's why I told you to go find them. If I knew where they were, I would have told you to go get them. Or you could ask your mother.

La stessa idea vale:

• usa "get" per un metodo che restituisce un'informazione disponibile a basso costo (e può essere probabilmente ottimizzata o altrimenti ottimizzata) o per un'informazione posseduta unicamente da questo oggetto.

• usa "trova" per un metodo che funziona per ottenere un'informazione, o usa altri oggetti per trovarlo.

Trova implica non avere il risultato, come quando si esegue una query di database con alcuni parametri che possono cambiare tra le chiamate. Get, d'altra parte, implica che i risultati siano noti al metodo in anticipo o non cambieranno una volta noti, che non ci sono parametri per la chiamata.
Quindi, userei ad esempio Customer findCustomerById (long customerId) e Customer getCustomer ()

Applico il seguente schema:

• Foo GetFoo() non può restituire null e la sua complessità è O (log (n)) o meno
• bool TryGetFoo(out Foo) può restituire null e la sua complessità è O (log (n)) o meno
• Foo FindFoo() non può restituire null e la sua complessità è maggiore di O (log (n))
• bool TryFindFoo(out Foo) può restituire null e la sua complessità è maggiore di O (log (n))

In questo modo il codice è abbastanza chiaro sull'intento e sulla complessità che ci si può aspettare.

Tipicamente, i Getter sono per l'elenco diretto o per l'accesso al dizionario / set.
I Finder sono ricerca profonda, scansione completa dell'elenco, ecc ...

Nel tuo caso:

public bool TryGetRevision( Item item, out String revision ) 
{
    service.load( item, "revision" );
    // there is usually more work to do before getting the data..
    try 
    {
        revision = item.get_revision();
        return true;
    }
    catch( NotLoadedException exception )
    {
        log.error( "Property named 'property_name' was not loaded", exception );
        revision = "";
        return false;
    }
}

get è appropriato in ogni caso _ infatti spesso si presume che per ottenere qualcosa devi prima trovarlo. Quindi, se non sei sicuro, utilizza get .

Vorrei usare find per metodi come findMinimum() o findOptimal() , cioè dove c'è un algoritmo speciale che calcola il valore di ritorno, e non fa semplicemente una richiesta al DB, al file system, al server remoto , ecc. per ricevere alcuni dati.

Non utilizzare trova o ottieni prefissi. Questa è una violazione di UniformAccessPrinciple coniato da bertrand meyer. Perché non creare un metodo come il seguente:

public String revision(Item item)

Generalmente userò Get per recuperare un oggetto / valore e Find per recuperare la sua posizione (in una matrice, per esempio).

per esempio:

object o = obj.GetItem( 'name');

integer i = somearray.Find( 'name');

Per me, find implica che ci può essere più di un risultato presente. get implica solo uno.